get-smart 0.0.1

data/files/rails/forms/beginner/display_error_messages.md

@@ -0,0 +1,21 @@
+## 🚨 Displaying error messages
+To show validation errors next to form fields, wrap checks for `object.errors` in your form view. Displaying errors improves UX by providing immediate feedback. Iterate over `@model.errors.full_messages` to list all messages.
+
+```erb
+<%= form_with model: @user, local: true do |f| %>
+  <% if @user.errors.any? %>
+    <div class="errors">
+      <h2><%= pluralize(@user.errors.count, "error") %> prohibited this user from saving:</h2>
+      <ul>
+        <% @user.errors.full_messages.each do |msg| %>
+          <li><%= msg %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <%= f.label :email %>
+  <%= f.email_field :email %>
+  <%= f.submit %>
+<% end %>
+```

data/files/rails/forms/beginner/file_upload_field.md

@@ -0,0 +1,10 @@
+## 📁 Adding file upload fields
+Use `file_field` to let users upload files. Ensure your form has `multipart: true` to handle binary data. In the controller, permit the file parameter and store it with Active Storage or another library.
+
+```ruby
+<%= form_with model: @avatar, local: true, multipart: true do |f| %>
+  <%= f.label :image, "Upload Avatar" %>
+  <%= f.file_field :image %>
+  <%= f.submit "Upload" %>
+<% end %>
+```

data/files/rails/forms/beginner/form_tag_basics.md

@@ -0,0 +1,10 @@
+## 📝 Creating a form with `form_tag`
+Use `form_tag` to build forms not directly tied to a model, such as search forms or filters. It lets you specify the URL and HTTP method manually. Handle the parameters in the controller accordingly.
+
+```ruby
+<%= form_tag search_posts_path, method: :get do %>
+  <%= label_tag :query, "Search Posts" %>
+  <%= text_field_tag :query, params[:query] %>
+  <%= submit_tag "Search" %>
+<% end %>
+```

data/files/rails/forms/beginner/form_with_model.md

@@ -0,0 +1,10 @@
+## 📝 Using `form_with` with a model
+`form_with` is the recommended way to build forms backed by models in Rails 5.1+. It automatically sets the correct URL and HTTP method based on whether the record is new or existing. Use the `local: true` option to disable AJAX and keep it simple.
+
+```ruby
+<%= form_with model: @user, local: true do |form| %>
+  <%= form.label :name %>
+  <%= form.text_field :name %>
+  <%= form.submit "Save" %>
+<% end %>
+```

data/files/rails/forms/beginner/nested_fields_for.md

@@ -0,0 +1,23 @@
+## 🧩 Building nested forms with `fields_for`
+When working with associated models, like a blog with comments, use `fields_for` inside your main form. This allows creating or editing child records alongside the parent. Remember to accept nested attributes in the parent model.
+
+```ruby
+# app/models/post.rb
+class Post < ApplicationRecord
+  has_many :comments
+  accepts_nested_attributes_for :comments
+end
+
+# in view:
+<%= form_with model: @post, local: true do |f| %>
+  <%= f.label :title %>
+  <%= f.text_field :title %>
+
+  <%= f.fields_for :comments do |c| %>
+    <%= c.label :body, "Comment" %>
+    <%= c.text_area :body %>
+  <% end %>
+
+  <%= f.submit "Save Post with Comments" %>
+<% end %>
+```

data/files/rails/forms/beginner/password_field_basics.md

@@ -0,0 +1,9 @@
+## 🔒 Creating password fields
+For sensitive inputs like passwords, use `password_field` to mask the input. It functions similarly to `text_field` but hides characters for security. Combine it with validation in the model to enforce length or complexity.
+
+```ruby
+<%= form_with model: @user, local: true do |f| %>
+  <%= f.label :password %>
+  <%= f.password_field :password %>
+<% end %>
+```

data/files/rails/forms/beginner/select_dropdown.md

@@ -0,0 +1,9 @@
+## 📋 Generating dropdowns with `select`
+Use `select` to present a list of options for a form attribute. It can take an array of pairs or a collection of Active Record objects. The helper links the selected value to your model attribute.
+
+```ruby
+<%= form_with model: @order, local: true do |f| %>
+  <%= f.label :status %>
+  <%= f.select :status, Order.statuses.keys.map { |s| [s.humanize, s] }, prompt: "Choose status" %>
+<% end %>
+```

data/files/rails/forms/beginner/text_field_and_label.md

@@ -0,0 +1,9 @@
+## ✍️ Adding text fields and labels
+Labels help users understand what input is expected, and pairing them with form helpers improves accessibility. Use `form.label` alongside `form.text_field` or their tag-based counterparts. This structure also auto-links the label to the input.
+
+```ruby
+<%= form_with model: @article, local: true do |f| %>
+  <%= f.label :title, "Article Title" %>
+  <%= f.text_field :title, placeholder: "Enter a title" %>
+<% end %>
+```

data/files/rails/forms/expert/action_text_integration.md

@@ -0,0 +1,27 @@
+## 🎨 Integrating Action Text and Active Storage in Forms
+Leverage `form.rich_text_area` to include Trix editors with direct file uploads through Active Storage. Configure storage service for direct uploads, enabling drag-and-drop attachments in your form.
+
+```ruby
+# app/views/articles/_form.html.erb
+<%= unified_form_with model: @article do |f| %>
+  <%= f.input_field :title %>
+  <%= f.rich_text_area :content %>
+  <%= f.submit %>
+<% end %>
+```
+
+```js
+// app/javascript/controllers/direct_uploads_controller.js
+import { Controller } from '@hotwired/stimulus'
+import * as DirectUpload from '@rails/activestorage'
+export default class extends Controller {
+  connect() {
+    this.element.querySelectorAll('input[type=file]').forEach(input => {
+      new DirectUpload(input, this.directUploadUrl()).start()
+    })
+  }
+  directUploadUrl() {
+    return '/rails/active_storage/direct_uploads'
+  }
+}
+```

data/files/rails/forms/expert/advanced_strong_parameters.md

@@ -0,0 +1,21 @@
+## 🚀 Advanced Strong Parameters with Conditional and Dynamic Attributes
+Handle dynamic nested parameters when you need to permit attributes based on runtime conditions. Use `permit` with splat operators and conditional logic to tighten security while supporting flexible forms.
+
+```ruby
+# In ProjectsController
+def project_params
+  permitted = [:name, :deadline]
+  permitted << { tasks_attributes: [:id, :title, :_destroy] } if current_user.admin?
+  permitted << :priority if params[:project][:priority].present?
+  params.require(:project).permit(*permitted)
+end
+```
+
+For deeply nested hashes, transform keys before permitting:
+
+```ruby
+# Convert camelCase to snake_case keys
+snake = params[:data].to_unsafe_h.deep_transform_keys { |key| key.to_s.underscore }
+clean = ActionController::Parameters.new(snake)
+clean.require(:project).permit(:name, :status)
+```

data/files/rails/forms/expert/custom_form_builder.md

@@ -0,0 +1,24 @@
+## 🛠️ Custom Form Builder for Unified Input DSL
+Create a centralized form builder to enforce consistent markup, error handling, and custom inputs across your app. By subclassing `ActionView::Helpers::FormBuilder`, you can define helper methods (e.g., `f.input_field`) that wrap labels, inputs, and error messages automatically.
+
+```ruby
+# app/helpers/unified_form_builder.rb
+class UnifiedFormBuilder < ActionView::Helpers::FormBuilder
+  def input_field(attribute, **options)
+    label_html = label(attribute, class: 'form-label')
+    input_html = super(attribute, class: 'form-control', **options)
+    errors = @object.errors[attribute].map { |e| @template.content_tag(:div, e, class: 'invalid-feedback') }.join.html_safe
+    @template.content_tag(:div, class: "mb-3 #{'has-error' if errors.present?}") do
+      label_html + input_html + errors
+    end
+  end
+end
+
+# In ApplicationHelper
+def unified_form_with(**options, &block)
+  options[:builder] = UnifiedFormBuilder
+  form_with(**options, &block)
+end
+```
+
+Use `unified_form_with model: @user` in your views to get consistent styling and error display.

data/files/rails/forms/expert/dynamic_nested_forms.md

@@ -0,0 +1,39 @@
+## ⚡ Dynamic Nested Forms with Stimulus and Turbo Frames
+Implement real-time addition and removal of nested fields without full-page reloads by combining Turbo Frames with a Stimulus controller. The controller inserts a template for new nested items and handles removal, preserving parameter naming for strong parameters.
+
+```erb
+<!-- app/views/projects/_form.html.erb -->
+<%= unified_form_with model: @project do |f| %>
+  <%= f.input_field :name %>
+
+  <turbo-frame id="tasks">
+    <%= f.fields_for :tasks do |task_fields| %>
+      <%= render 'task_fields', f: task_fields %>
+    <% end %>
+  </turbo-frame>
+
+  <button type="button" data-controller="nested" data-action="nested#add" data-nested-target-template-id="task-template">Add Task</button>
+  <%= f.submit 'Save' %>
+<% end %>
+
+<!-- app/views/projects/_task_fields.html.erb -->
+<div data-nested-target="item">
+  <%= f.input_field :title %>
+  <button type="button" data-action="nested#remove">Remove</button>
+</div>
+
+<!-- app/javascript/controllers/nested_controller.js -->
+import { Controller } from "@hotwired/stimulus"
+export default class extends Controller {
+  static targets = ["item", "template"]
+  add() {
+    const content = document.getElementById(this.templateId).innerHTML
+    this.element.querySelector('turbo-frame').insertAdjacentHTML('beforeend', content)
+  }
+  remove(event) {
+    event.currentTarget.closest('[data-nested-target="item"]').remove()
+  }
+}
+```
+
+Ensure your `Project` model accepts nested attributes and configure strong parameters.

data/files/rails/forms/expert/form_object_pattern.md

@@ -0,0 +1,38 @@
+## 🔧 Form Object Pattern with ActiveModel for Complex Workflows
+Use PORO form objects to decouple form logic from AR models when saving to multiple tables or invoking service calls. Include `ActiveModel::Model` and define custom validations, mapping input to services in a single transaction.
+
+```ruby
+# app/forms/user_signup_form.rb
+class UserSignupForm
+  include ActiveModel::Model
+  attr_accessor :email, :password, :profile_attributes
+  validates :email, format: /@/, presence: true
+  validates :password, length: { minimum: 8 }
+  validate :unique_email
+
+  def save
+    return false unless valid?
+    ActiveRecord::Base.transaction do
+      user = User.create!(email: email, password: password)
+      user.create_profile!(profile_attributes)
+      WelcomeMailer.welcome_email(user).deliver_later
+    end
+    true
+  end
+
+  private
+  def unique_email
+    errors.add(:email, 'is taken') if User.exists?(email: email)
+  end
+end
+
+# In controller
+def create
+  form = UserSignupForm.new(signup_params)
+  if form.save
+    redirect_to root_path, notice: 'Signed up!'
+  else
+    render :new
+  end
+end
+```

data/files/rails/forms/expert/i18n_and_accessibility.md

@@ -0,0 +1,22 @@
+## 🌐 Internationalization and Accessibility in Forms
+Combine Rails I18n with ARIA attributes to produce localized labels, placeholders, and error messages accessible to screen readers. Use `t` helpers with interpolation and add `aria-describedby` linking inputs to error or hint elements.
+
+```erb
+<%= unified_form_with model: @order do |f| %>
+  <label for="order_quantity"><%= t('orders.quantity') %></label>
+  <%= f.number_field :quantity,
+        placeholder: t('orders.quantity_hint'),
+        aria: { describedby: 'quantity_hint quantity_error' } %>
+
+  <small id="quantity_hint" class="form-text text-muted">
+    <%= t('orders.quantity_hint') %>
+  </small>
+  <% if @order.errors[:quantity].present? %>
+    <div id="quantity_error" class="invalid-feedback">
+      <%= @order.errors[:quantity].join(', ') %>
+    </div>
+  <% end %>
+
+  <%= f.submit t('orders.submit') %>
+<% end %>
+```

data/files/rails/forms/expert/polymorphic_form_inputs.md

@@ -0,0 +1,27 @@
+## 🧩 Polymorphic Form Inputs for Multiple Association Types
+Construct a single form supporting multiple associated record types by inspecting a type field and rendering conditional inputs. This reduces duplication when embedding comments, tags, or attachments polymorphically.
+
+```erb
+<%= unified_form_with model: @attachment do |f| %>
+  <%= f.input_field :attachable_type, as: :select, collection: %w[Post Comment], data: { action: 'change->poly#toggle' } %>
+  <div data-poly-target="Post">
+    <%= f.input_field :attachable_id, as: :select, collection: Post.all.pluck(:title, :id) %>
+  </div>
+  <div data-poly-target="Comment" hidden>
+    <%= f.input_field :attachable_id, as: :select, collection: Comment.all.pluck(:body, :id) %>
+  </div>
+  <%= f.submit %>
+<% end %>
+```
+
+```js
+// app/javascript/controllers/poly_controller.js
+import { Controller } from '@hotwired/stimulus'
+export default class extends Controller {
+  static targets = ['Post', 'Comment']
+  toggle(event) {
+    this.PostTarget.hidden = event.target.value !== 'Post'
+    this.CommentTarget.hidden = event.target.value !== 'Comment'
+  }
+}
+```

data/files/rails/forms/expert/real_time_validations.md

@@ -0,0 +1,25 @@
+## 📦 Real-Time Validations with Stimulus and Custom Endpoints
+Provide instant feedback by calling a validation endpoint from a Stimulus controller on input events. Render JSON errors and update the form inline without blocking typing.
+
+```js
+// app/javascript/controllers/validation_controller.js
+import { Controller } from '@hotwired/stimulus'
+export default class extends Controller {
+  static targets = ['input', 'feedback']
+  validate() {
+    fetch(`/users/validate?field=${this.inputTarget.name}&value=${this.inputTarget.value}`)
+      .then(res => res.json())
+      .then(data => {
+        this.feedbackTarget.textContent = data.error || ''
+        this.inputTarget.classList.toggle('is-invalid', !!data.error)
+      })
+  }
+}
+```
+
+```erb
+<%= form_with model: @user, html: { data: { controller: 'validation' } } do |f| %>
+  <%= f.input_field :username, data: { action: 'input->validation#validate', validation_target: 'input' } %>
+  <div data-validation-target="feedback" class="invalid-feedback"></div>
+<% end %>
+```

data/files/rails/forms/expert/select_options_caching.md

@@ -0,0 +1,24 @@
+## 🔄 Performance Optimization: Caching Heavy Select Collections
+Avoid repeated DB hits for large select inputs by caching collections with low TTL and invalidation hooks. Wrap the collection fetch in `Rails.cache.fetch` and expire on relevant model callbacks.
+
+```ruby
+# app/helpers/form_collections.rb
+module FormCollections
+  def cached_user_options
+    Rails.cache.fetch('user_options', expires_in: 1.hour) do
+      User.active.order(:name).pluck(:name, :id)
+    end
+  end
+end
+
+# In a model or observer
+after_commit :expire_user_options_cache, on: [:create, :update, :destroy]
+
+def expire_user_options_cache
+  Rails.cache.delete('user_options')
+end
+```
+
+```erb
+<%= f.select :assignee_id, cached_user_options, prompt: 'Select user' %>
+```

data/files/rails/forms/middle/checkbox_array_input.md

@@ -0,0 +1,12 @@
+## ☑️ Manage multi-select checkboxes for arrays
+To create a set of checkboxes that submit an array, use `check_box_tag` with `name` ending in `[]`. In your controller, Rails will provide an array of selected values.
+
+```erb
+<%= form_with(url: tags_path) do |form| %>
+  <% Tag.all.each do |tag| %>
+    <%= check_box_tag 'post[tag_ids][]', tag.id, @post.tag_ids.include?(tag.id) %>
+    <%= label_tag "post_tag_ids_#{tag.id}", tag.name %><br>
+  <% end %>
+  <%= form.submit 'Save Tags' %>
+<% end %>
+```

data/files/rails/forms/middle/collection_select_association.md

@@ -0,0 +1,9 @@
+## 🔗 Use `collection_select` for associations
+When working with Active Record associations, `collection_select` helps bind your select fields directly to model attributes. It automatically sets the selected option based on the record’s current value.
+
+```erb
+<%= form_with(model: @post) do |form| %>
+  <%= form.collection_select :category_id, Category.all, :id, :name, prompt: 'Choose Category' %>
+  <%= form.submit %>
+<% end %>
+```

data/files/rails/forms/middle/csrf_token_auto.md

@@ -0,0 +1,9 @@
+## 🔒 Ensure CSRF protection in forms
+Rails automatically includes a hidden `authenticity_token` in every form helper. You can disable it with `authenticity_token: false`, but only if you have another CSRF mitigation strategy in place.
+
+```erb
+<%= form_with(model: @comment, authenticity_token: false) do |form| %>
+  <%= form.text_area :body %>
+  <%= form.submit %>
+<% end %>
+```

data/files/rails/forms/middle/custom_error_highlighting.md

@@ -0,0 +1,9 @@
+## 🛑 Customize form error highlighting
+By default, Rails wraps fields with errors in a div. You can override this behavior by redefining `ActionView::Base.field_error_proc` in an initializer to match your CSS framework.
+
+```ruby
+# config/initializers/field_error_proc.rb
+ActionView::Base.field_error_proc = Proc.new do |html_tag, _instance|
+  "<div class=\"field_with_errors custom-error\">#{html_tag}</div>".html_safe
+end
+```

data/files/rails/forms/middle/custom_form_builder.md

@@ -0,0 +1,18 @@
+## ✨ Create a custom `FormBuilder`
+Subclass `ActionView::Helpers::FormBuilder` to encapsulate repetitive patterns or styling. Then pass it to your form helpers via the `builder` option.
+
+```ruby
+# lib/custom_form_builder.rb
+class CustomFormBuilder < ActionView::Helpers::FormBuilder
+  def labeled_field(method, label_text = nil, **options)
+    label(method, label_text) + text_field(method, options.merge(class: 'custom-field'))
+  end
+end
+```
+
+```erb
+<%= form_with(model: @product, builder: CustomFormBuilder) do |form| %>
+  <%= form.labeled_field :name, 'Product Name' %>
+  <%= form.submit %>
+<% end %>
+```

data/files/rails/forms/middle/custom_input_options.md

@@ -0,0 +1,10 @@
+## 🎨 Customize input HTML attributes
+Rails form helpers accept HTML options to style and add hints to your inputs. Use options like `placeholder`, `class`, or `data` attributes directly in the helper call.
+
+```erb
+<%= form_with(model: @user) do |form| %>
+  <%= form.email_field :email, placeholder: 'user@example.com', class: 'form-control' %>
+  <%= form.password_field :password, data: { toggle: 'password-visibility' } %>
+  <%= form.submit 'Register', class: 'btn btn-primary' %>
+<% end %>
+```

data/files/rails/forms/middle/file_field_active_storage.md

@@ -0,0 +1,16 @@
+## 📂 Upload files with Active Storage
+Integrate file uploads seamlessly by using `form.file_field` with Rails Active Storage. Ensure your model has `has_one_attached` or `has_many_attached` for attachments.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  has_one_attached :avatar
+end
+```
+
+```erb
+<%= form_with(model: @user) do |form| %>
+  <%= form.file_field :avatar %>
+  <%= form.submit 'Upload Avatar' %>
+<% end %>
+```

data/files/rails/forms/middle/form_with_remote_submissions.md

@@ -0,0 +1,9 @@
+## 🚀 Prefer `form_with` for remote submissions
+form_with is the unified helper for creating forms in Rails 5 and above. To enable AJAX submissions, set `local: false`, which will automatically use `remote: true` under the hood and handle CSRF tokens and method spoofing for you.
+
+```erb
+<%= form_with(model: @article, local: false) do |form| %>
+  <%= form.text_field :title %>
+  <%= form.submit "Save" %>
+<% end %>
+```

data/files/rails/forms/middle/i18n_labels.md

@@ -0,0 +1,19 @@
+## 🌐 Leverage I18n for labels and placeholders
+Use Rails’ I18n support to translate form labels and placeholders. Define your translations in locale files and call `t` within form helpers for consistency across languages.
+
+```yaml
+# config/locales/en.yml
+en:
+  activerecord:
+    attributes:
+      user:
+        email: 'Email Address'
+```
+
+```erb
+<%= form_with(model: @user) do |form| %>
+  <%= form.label :email, t('activerecord.attributes.user.email') %>
+  <%= form.email_field :email, placeholder: t('activerecord.attributes.user.email') %>
+  <%= form.submit %>
+<% end %>
+```

data/files/rails/forms/middle/nested_fields_for_models.md

@@ -0,0 +1,21 @@
+## 🧩 Handle nested attributes with `fields_for`
+For models that `accepts_nested_attributes_for` child records, use `fields_for` within your form to create or edit associated records. Make sure to permit nested parameters in your controller.
+
+```ruby
+# app/models/order.rb
+class Order < ApplicationRecord
+  has_many :items
+  accepts_nested_attributes_for :items, allow_destroy: true
+end
+```
+
+```erb
+<%= form_with(model: @order) do |form| %>
+  <%= form.text_field :customer_name %>
+  <%= form.fields_for :items do |item_fields| %>
+    <%= item_fields.text_field :product_name %>
+    <%= item_fields.number_field :quantity %>
+  <% end %>
+  <%= form.submit %>
+<% end %>
+```

data/files/rails/helpers/advanced/caching_heavy_helper_computations.md

@@ -0,0 +1,21 @@
+## ⚡ Caching Heavy Helper Computations
+
+Use Rails cache to store expensive helper results and dramatically improve view rendering performance. By keying on model attributes or parameters, you ensure fresh data when underlying records change.
+
+```ruby
+# app/helpers/analytics_helper.rb
+module AnalyticsHelper
+  def user_report(user)
+    Rails.cache.fetch([:user_report, user.id, user.updated_at.to_i], expires_in: 6.hours) do
+      # Perform heavy data aggregation, SQL queries, or API calls
+      compute_user_metrics(user)
+    end
+  end
+
+  private
+
+  def compute_user_metrics(user)
+    # heavy logic here
+  end
+end
+```

data/files/rails/helpers/advanced/dynamic_content_tag_with_blocks.md

@@ -0,0 +1,20 @@
+## 🎨 Dynamic content_tag with Blocks
+
+Combine `content_tag` and blocks to construct nested HTML components. This approach encapsulates complex markup within a helper while yielding to a block for custom content insertion. It simplifies view code and promotes reusable UI components.
+
+```ruby
+# app/helpers/posts_helper.rb
+module PostsHelper
+  def card_for(post, &block)
+    content_tag :div, class: 'card' do
+      concat content_tag(:div, image_tag(post.image_url), class: 'card-img-top')
+      concat(
+        content_tag(:div, class: 'card-body') do
+          concat content_tag(:h5, post.title, class: 'card-title')
+          concat capture(&block) if block_given?
+        end
+      )
+    end
+  end
+end
+```

data/files/rails/helpers/advanced/dynamic_partial_resolution_with_lookup_context.md

@@ -0,0 +1,17 @@
+## 🔍 Dynamic Partial Resolution with lookup_context
+
+Use `lookup_context` to verify existence or locate templates in custom paths before rendering. This technique supports feature toggles or theming by selecting partials at runtime.
+
+```ruby
+# app/helpers/theme_helper.rb
+module ThemeHelper
+  def themed_partial(base, theme)
+    path = "#{base}/#{theme}"
+    if lookup_context.find_all("#{path}").any?
+      render partial: path
+    else
+      render partial: "#{base}/default"
+    end
+  end
+end
+```

data/files/rails/helpers/advanced/extending_javascript_helper_for_i18n.md

@@ -0,0 +1,15 @@
+## 🛠️ Extending JavaScript Helpers for I18n
+
+Leverage `ActionView::Helpers::JavaScriptHelper` to safely embed translated messages or dynamic data in JavaScript. Use `j` (alias for `escape_javascript`) to prevent injection attacks.
+
+```ruby
+# app/helpers/application_helper.rb
+module ApplicationHelper
+  include ActionView::Helpers::JavaScriptHelper
+
+  def i18n_js_variable(keys)
+    messages = keys.map { |k| [k, I18n.t(k)] }.to_h
+    javascript_tag("window.I18nMessages = #{j(messages.to_json)};")
+  end
+end
+```

data/files/rails/helpers/advanced/injecting_helpers_into_mailers.md

@@ -0,0 +1,17 @@
+## 📧 Injecting View Helpers into Mailers
+
+Include view helper modules in mailers to reuse formatting, URL helpers, or UI components directly within email templates. This ensures consistency between your web views and email content.
+
+```ruby
+# app/mailers/application_mailer.rb
+class ApplicationMailer < ActionMailer::Base
+  helper ApplicationHelper
+  helper PostsHelper
+  default from: 'notifications@example.com'
+end
+
+# app/views/user_mailer/welcome_email.html.erb
+<%= card_for(@user) do %>
+  <p>Welcome to our platform, <%= @user.name %>!</p>
+<% end %>
+```

data/files/rails/helpers/advanced/render_partials_from_helpers.md

@@ -0,0 +1,17 @@
+## 🔄 Rendering Partials with Dynamic Locals from Helpers
+
+Invoke `render` directly in a helper to consolidate repeated partial logic. Pass in collections, locals, or dynamic partial paths to keep views DRY and maintainable.
+
+```ruby
+# app/helpers/comments_helper.rb
+module CommentsHelper
+  def comment_list(comments)
+    render partial: 'comments/comment', collection: comments, as: :comment
+  end
+
+  def dynamic_comment_view(comment, view_name)
+    partial = "comments/#{view_name}"
+    render partial: partial, locals: { comment: comment }
+  end
+end
+```

data/files/rails/helpers/beginner/rails_helper_content_tag.md

@@ -0,0 +1,10 @@
+## 🏷️ Tip: Create HTML tags with `content_tag`
+The `content_tag` helper lets you generate arbitrary HTML tags with content and attributes, useful for custom wrappers or tags not covered by built-ins.
+
+```erb
+<%= content_tag :div, class: 'alert alert-info' do %>
+  <strong>Notice:</strong> Your changes were saved.
+<% end %>
+```
+
+Use blocks to nest content and pass options for HTML attributes.