### Install templates-rails Gem

Source: https://github.com/ancez/templates-rails/blob/master/README.md

Instructions for installing the templates-rails gem for development environments. This involves adding the gem to your Gemfile and running bundle install, or installing it directly using the gem install command.

```ruby
gem 'templates-rails'
```

--------------------------------

### Create Templates Directory and Example Template

Source: https://context7.com/ancez/templates-rails/llms.txt

Set up the necessary directory structure and create an example .html.erb template file within app/views/templates. This template will be accessible via the gem's interface.

```bash
# Create templates directory
mkdir -p app/views/templates

# Create an example template
cat > app/views/templates/example.html.erb << 'EOF'
<% provide(:title, 'Example Template') %>

<div style="padding: 20px;">
  <h1>Welcome to Templates</h1>
  <p>This is an example template file.</p>
</div>
EOF
```

--------------------------------

### Install Templates Rails Gem

Source: https://context7.com/ancez/templates-rails/llms.txt

Add the 'templates-rails' gem to your Gemfile for development and install dependencies using Bundler.

```ruby
# Gemfile
group :development do
  gem 'templates-rails'
end
```

```bash
# Install dependencies
bundle install
```

--------------------------------

### Basic Template with Title

Source: https://context7.com/ancez/templates-rails/llms.txt

An example of a basic HTML template file ('landing_page.html.erb') that sets a page title using `provide(:title, ...)` and includes basic content for a landing page.

```erb
# app/views/templates/landing_page.html.erb
<% provide(:title, 'Landing Page') %>

<section class="hero">
  <h1>Welcome to Our Application</h1>
  <p>This is a prototype landing page.</p>
  <button>Get Started</button>
</section>

<section class="features">
  <div class="feature">
    <h3>Feature One</h3>
    <p>Description of feature one.</p>
  </div>
  <div class="feature">
    <h3>Feature Two</h3>
    <p>Description of feature two.</p>
  </div>
</section>

<!-- Access at: http://localhost:3000/templates/landing_page -->
```

--------------------------------

### Nested Template Example

Source: https://context7.com/ancez/templates-rails/llms.txt

An example of how to create nested templates within the app/views/templates directory. This template, 'dashboard/overview.html.erb', demonstrates a basic dashboard layout and can be accessed at /templates/dashboard/overview.

```erb
# app/views/templates/dashboard/overview.html.erb
<% provide(:title, 'Dashboard Overview') %>

<div class="dashboard">
  <h2>Overview</h2>
  <div class="metrics">
    <div class="metric-card">
      <h3>Total Users</h3>
      <p>1,234</p>
    </div>
    <div class="metric-card">
      <h3>Active Sessions</h3>
      <p>567</p>
    </div>
  </div>
</div>

# Access at: http://localhost:3000/templates/dashboard/overview
```

--------------------------------

### Integration with Rails Helpers and Assets in ERB

Source: https://context7.com/ancez/templates-rails/llms.txt

Shows how templates can seamlessly use Rails helpers, the asset pipeline, and application helpers. This example demonstrates using `link_to`, `image_tag`, `content_tag`, `button_to`, `javascript_include_tag`, and Rails' time formatting within an ERB template.

```erb
# app/views/templates/styled_page.html.erb
<% provide(:title, 'Styled Page') %>

<div class="container">
  <h1><%= link_to 'Home', root_path %></h1>

  <%= image_tag 'logo.png', alt: 'Logo', class: 'logo' %>

  <div class="card">
    <%= content_tag :div, class: 'card-body' do %>
      <h3>Card Title</h3>
      <p>Card content with Rails helpers.</p>
      <%= button_to 'Action', '#', method: :post, class: 'btn' %>
    <% end %>
  </div>

  <p>Current time: <%= Time.current.strftime('%Y-%m-%d %H:%M') %></p>

  <%= javascript_include_tag 'application' %>
</div>
```

--------------------------------

### Nested Directory Structure for Templates in ERB

Source: https://context7.com/ancez/templates-rails/llms.txt

Illustrates organizing templates into nested directories, such as `app/views/templates/users/`. This allows for better structure based on features or sections. The example shows `profile.html.erb` and `settings.html.erb` within the `users` directory.

```erb
# app/views/templates/users/profile.html.erb
<% provide(:title, 'User Profile') %>

<div class="profile">
  <img src="https://via.placeholder.com/150" alt="Avatar">
  <h2>John Doe</h2>
  <p>john.doe@example.com</p>
  <button>Edit Profile</button>
</div>

# app/views/templates/users/settings.html.erb
<% provide(:title, 'User Settings') %>

<form>
  <label>Email Notifications</label>
  <input type="checkbox" checked>

  <label>Theme</label>
  <select>
    <option>Light</option>
    <option>Dark</option>
  </select>

  <button type="submit">Save Settings</button>
</form>

# Directory structure:
# app/views/templates/
#   ├── users/
#   │   ├── profile.html.erb
#   │   └── settings.html.erb
#   └── homepage.html.erb

# Access at:
# http://localhost:3000/templates/users (shows index of templates in users/)
# http://localhost:3000/templates/users/profile
# http://localhost:3000/templates/users/settings
```

--------------------------------

### Routes Configuration for Templates Engine in Ruby

Source: https://context7.com/ancez/templates-rails/llms.txt

Defines how routes are automatically configured for the `Templates::Engine`. It sets a root path for the engine and a flexible `show` route that accepts any ID pattern. Example usage in templates for linking to the engine's paths is also provided.

```ruby
# config/routes.rb (within Templates::Engine)
Templates::Engine.routes.draw do
  root 'templates#index'
  get ':id', to: 'templates#show', as: :template, constraints: { id: /.*/ }
end

# Available routes:
# templates_engine.root_path          -> /templates
# templates_engine.template_path(id)  -> /templates/:id

# Example usage in templates:
# <%= link_to 'Back to Templates', templates_engine.root_path %>
# <%= link_to 'View Profile', templates_engine.template_path('users/profile') %>
```

--------------------------------

### Test Exclusion of Partials from Listing (RSpec)

Source: https://context7.com/ancez/templates-rails/llms.txt

This RSpec feature test ensures that partial files (e.g., starting with an underscore) are not displayed as standalone links on the main templates index page. It confirms the gem correctly filters out partials.

```ruby
require 'rails_helper'

RSpec.describe 'Templates functionality', type: :feature do
  it 'excludes partials from the listing' do
    visit '/templates'
    expect(page).not_to have_link 'Partials'
  end
end
```

--------------------------------

### Templates Module Configuration for Parent Controller in Ruby

Source: https://context7.com/ancez/templates-rails/llms.txt

Configures the base controller for templates within the `Templates` module. The `parent_controller` attribute can be set to specify which controller templates should inherit from. This example shows default configuration and advanced conditional configuration based on the Rails environment.

```ruby
# lib/templates-rails.rb
module Templates
  mattr_accessor :parent_controller
  @@parent_controller = 'ApplicationController'
end

# Advanced configuration example
# config/initializers/templates.rb
if Rails.env.development?
  # Use custom base controller with authentication
  Templates.parent_controller = 'DevelopmentController'

  # Or bypass authentication for templates
  Templates.parent_controller = 'ActionController::Base'
end

# config/environments/production.rb
# Disable templates in production by not mounting the engine
Rails.application.configure do
  # Templates engine won't be available in production
  config.consider_all_requests_local = false
end
```

--------------------------------

### Configure Parent Controller for templates-rails

Source: https://github.com/ancez/templates-rails/blob/master/README.md

Guides on how to set the parent controller for the templates-rails gem. This is crucial for compatibility with tenant-based applications or when a custom inheritance controller is used. The default is `ApplicationController`, but it can be changed to `ActionController::Base` or other controllers if `ApplicationController` is not present.

```ruby
Templates.parent_controller = 'ApplicationController'
```

--------------------------------

### Templates Rails Engine Configuration

Source: https://context7.com/ancez/templates-rails/llms.txt

Configuration for the Templates Rails engine. It automatically mounts itself at '/templates' and sets up asset precompilation for the templates interface. No manual route configuration is needed in config/routes.rb.

```ruby
# lib/templates/engine.rb
module Templates
  class Engine < ::Rails::Engine
    initializer 'templates', before: :load_config_initializers do
      Rails.application.routes.append do
        mount Templates::Engine => '/templates'
      end
    end

    initializer 'templates.assets' do
      if Rails.application.config.respond_to?(:assets)
        Rails.application.config.assets.precompile += %w( templates/application.css )
      end
    end
  end
end
```

```ruby
# config/routes.rb (automatic, no configuration needed)
# Templates::Engine routes are appended automatically
Rails.application.routes.draw do
  # Your application routes
  root 'home#index'

  # Templates engine is auto-mounted at /templates
end
```

--------------------------------

### TemplatesController Implementation

Source: https://context7.com/ancez/templates-rails/llms.txt

The TemplatesController handles rendering template files and directories. It dynamically inherits from the configured parent controller and renders templates based on the 'id' parameter, supporting both single files and nested directory structures.

```ruby
# app/controllers/templates_controller.rb
class TemplatesController < Templates.parent_controller.constantize
  def index
    render :index, layout: 'templates/index'
  end

  def show
    if params[:id].present? && File.directory?("./app/views/templates/#{params[:id]}")
      render :nested_index, layout: 'templates/index'
    else
      render "templates/#{params[:id]}", layout: 'templates/show'
    end
  end
end
```

--------------------------------

### Using Partials for Navigation in ERB

Source: https://context7.com/ancez/templates-rails/llms.txt

Demonstrates how to use partials to include reusable view components, specifically a navigation bar. The partial `_navigation.html.erb` is rendered within the `homepage.html.erb` template. Partials located in `partials` directories are excluded from the main template listing.

```erb
# app/views/templates/partials/_navigation.html.erb
<nav class="main-nav">
  <ul>
    <li><a href="#">Home</a></li>
    <li><a href="#">About</a></li>
    <li><a href="#">Contact</a></li>
  </ul>
</nav>

# app/views/templates/homepage.html.erb
<% provide(:title, 'Homepage') %>

<%= render 'templates/partials/navigation' %>

<div class="content">
  <h1>Homepage Content</h1>
  <p>This template uses a partial for navigation.</p>
</div>

<!-- Partials directory won't appear in the templates index -->
```

--------------------------------

### Test Navigation to Specific Template (RSpec)

Source: https://context7.com/ancez/templates-rails/llms.txt

This RSpec feature test confirms that users can navigate from the templates index page to a specific template's detail view by clicking a link. It checks for the presence of the expected content on the target template page.

```ruby
require 'rails_helper'

RSpec.describe 'Templates functionality', type: :feature do
  it 'navigates to a specific template' do
    visit '/templates'
    click_link 'Example'
    expect(page).to have_content 'Example Template'
  end
end
```

--------------------------------

### Test Template Index Page Display (RSpec)

Source: https://context7.com/ancez/templates-rails/llms.txt

This RSpec feature test verifies that the main templates index page is displayed correctly and contains the expected 'Templates' heading. It ensures basic accessibility of the template listing.

```ruby
require 'rails_helper'

RSpec.describe 'Templates functionality', type: :feature do
  it 'displays the templates index page' do
    visit '/templates'
    expect(page).to have_content 'Templates'
  end
end
```

--------------------------------

### Template with Custom Application Layout Override

Source: https://context7.com/ancez/templates-rails/llms.txt

This section indicates the possibility of overriding the default application layout for specific templates. The code snippet itself is not provided, but the context implies that a template can specify a different layout using `render layout: '...'`.

```erb
# Example for overriding layout:
# render "templates/my_template", layout: 'custom_layout'
# Or within the template file itself, if the layout is specified in the controller.
```

--------------------------------

### Configure Parent Controller Inheritance

Source: https://context7.com/ancez/templates-rails/llms.txt

Set the parent controller for the Templates engine in the development environment configuration. This allows customization for standard Rails apps, apps without ApplicationController, or tenant-based apps with custom base controllers.

```ruby
# config/environments/development.rb
Rails.application.configure do
  # For standard Rails apps
  Templates.parent_controller = 'ApplicationController'

  # For apps without ApplicationController
  Templates.parent_controller = 'ActionController::Base'

  # For tenant-based apps with custom base controller
  Templates.parent_controller = 'TenantController'
end
```

--------------------------------

### Admin Dashboard View in ERB

Source: https://context7.com/ancez/templates-rails/llms.txt

Defines the structure for an admin dashboard using ERB. It sets page titles and layout overrides, includes a sidebar navigation, and displays a user data table. This view is intended to be rendered with a specific admin layout.

```erb
<% provide(:title, 'Admin Dashboard') %>
<% provide(:layout_override, 'admin') %>

<div class="admin-content">
  <nav class="sidebar">
    <ul>
      <li><a href="#">Users</a></li>
      <li><a href="#">Settings</a></li>
      <li><a href="#">Reports</a></li>
    </ul>
  </nav>

  <main class="main-content">
    <h1>Admin Dashboard</h1>
    <table>
      <thead>
        <tr>
          <th>ID</th>
          <th>Name</th>
          <th>Email</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>1</td>
          <td>John Doe</td>
          <td>john@example.com</td>
        </tr>
      </tbody>
    </table>
  </main>
</div>

<!-- This will render with layouts/admin.html.erb instead of layouts/application.html.erb -->
```

--------------------------------

### Test Nested Template Directory Navigation (RSpec)

Source: https://context7.com/ancez/templates-rails/llms.txt

This RSpec feature test validates the handling of nested template directories. It checks if links within a nested directory are present and allows navigation to a specific nested template, verifying its content.

```ruby
require 'rails_helper'

RSpec.describe 'Templates functionality', type: :feature do
  it 'handles nested template directories' do
    visit '/templates/users'
    expect(page).to have_link 'Profile'
    expect(page).to have_link 'Settings'

    click_link 'Profile'
    expect(page).to have_content 'User Profile'
  end
end
```

--------------------------------

### Default Rails Error Page CSS

Source: https://github.com/ancez/templates-rails/blob/master/spec/dummy/public/500.html

Defines the visual appearance of the default Rails 500 error page. It sets the background, text alignment, font, and styles for the dialog box, heading, and paragraphs. No external dependencies are required.

```css
.rails-default-error-page { background-color: #EFEFEF; color: #2E2F30; text-align: center; font-family: arial, sans-serif; margin: 0; }
.rails-default-error-page div.dialog { width: 95%; max-width: 33em; margin: 4em auto 0; }
.rails-default-error-page div.dialog > div { border: 1px solid #CCC; border-right-color: #999; border-left-color: #999; border-bottom-color: #BBB; border-top: #B00100 solid 4px; border-top-left-radius: 9px; border-top-right-radius: 9px; background-color: white; padding: 7px 12% 0; box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17); }
.rails-default-error-page h1 { font-size: 100%; color: #730E15; line-height: 1.5em; }
.rails-default-error-page div.dialog > p { margin: 0 0 1em; padding: 1em; background-color: #F7F7F7; border: 1px solid #CCC; border-right-color: #999; border-left-color: #999; border-bottom-color: #999; border-bottom-left-radius: 4px; border-bottom-right-radius: 4px; border-top-color: #DADADA; color: #666; box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17); }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.