get-smart 0.0.1

data/files/rails/mailers/beginner/preview_emails.md

@@ -0,0 +1,15 @@
+## 👀 Previewing Emails in Development
+
+Rails Mailer Previews let you view email templates in the browser without sending real emails. Create a preview class under `test/mailers/previews/`.
+
+```ruby
+# test/mailers/previews/user_mailer_preview.rb
+class UserMailerPreview < ActionMailer::Preview
+  def welcome_email
+    user = User.first || User.new(name: 'Test', email: 'test@example.com')
+    UserMailer.welcome_email(user)
+  end
+end
+```
+
+Start your server and navigate to `http://localhost:3000/rails/mailers/user_mailer/welcome_email` to see the HTML and text previews.

data/files/rails/mailers/beginner/send_emails_controllers.md

@@ -0,0 +1,20 @@
+## 🔧 Sending Emails from Controllers
+
+You can invoke mailer methods directly in your controllers and choose whether to send emails synchronously (`deliver_now`) or asynchronously (`deliver_later`).
+
+```ruby
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  def create
+    @user = User.create(user_params)
+    if @user.persisted?
+      UserMailer.welcome_email(@user).deliver_now
+      redirect_to root_path, notice: 'Welcome email sent.'
+    else
+      render :new
+    end
+  end
+end
+```
+
+Use `deliver_now` for immediate sending; this blocks the request until the email is delivered.

data/files/rails/mailers/beginner/smtp_configuration.md

@@ -0,0 +1,22 @@
+## ⚙️ Configuring SMTP Settings
+
+Set up your SMTP provider in environment config files so ActionMailer knows how to connect and send emails. Here's an example for Gmail in development:
+
+```ruby
+# config/environments/development.rb
+Rails.application.configure do
+  config.action_mailer.delivery_method = :smtp
+  config.action_mailer.smtp_settings = {
+    address:              'smtp.gmail.com',
+    port:                 587,
+    domain:               'example.com',
+    user_name:            ENV['GMAIL_USERNAME'],
+    password:             ENV['GMAIL_PASSWORD'],
+    authentication:       'plain',
+    enable_starttls_auto: true
+  }
+  config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
+end
+```
+
+Ensure environment variables are set and restart your server to apply changes.

data/files/rails/mailers/beginner/test_mailers.md

@@ -0,0 +1,27 @@
+## ✅ Testing Mailers
+
+Use built‑in helpers to verify emails are enqueued, sent, and contain the correct content in your test suite. Here’s an example with RSpec:
+
+```ruby
+# spec/mailers/user_mailer_spec.rb
+require 'rails_helper'
+
+RSpec.describe UserMailer, type: :mailer do
+  describe '#welcome_email' do
+    let(:user) { create(:user, email: 'foo@example.com', name: 'Foo') }
+    let(:mail) { UserMailer.welcome_email(user) }
+
+    it 'renders the headers' do
+      expect(mail.subject).to eq('Welcome to My App')
+      expect(mail.to).to eq(['foo@example.com'])
+      expect(mail.from).to eq(['no-reply@example.com'])
+    end
+
+    it 'renders the body' do
+      expect(mail.body.encoded).to match("Hello #{user.name}")
+    end
+  end
+end
+```
+
+This ensures your mailer methods generate emails with the intended headers and content.

data/files/rails/mailers/expert/custom_delivery_method.md

@@ -0,0 +1,34 @@
+## 🎯 Implementing a Custom Delivery Method
+
+Hook into `ActionMailer::Base.add_delivery_method` to integrate proprietary SMTP servers or APIs. This allows you to override `deliver!` semantics entirely.
+
+```ruby
+# lib/delivery_methods/my_api.rb
+require 'net/http'
+module DeliveryMethods
+  class MyApi
+    def initialize(settings)
+      @api_key = settings[:api_key]
+    end
+
+    def deliver!(mail)
+      payload = {
+        to: mail.to,
+        subject: mail.subject,
+        body: mail.body.decoded
+      }
+      uri = URI.parse("https://api.example.com/send_email")
+      req = Net::HTTP::Post.new(uri)
+      req['Authorization'] = "Bearer #{@api_key}"
+      req.body = payload.to_json
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+    end
+  end
+end
+
+# config/initializers/mailer.rb
+ActionMailer::Base.add_delivery_method :my_api, DeliveryMethods::MyApi, api_key: Rails.application.credentials.email_api_key
+ActionMailer::Base.delivery_method = :my_api
+```
+
+This pattern decouples Rails from vendor SDKs and gives you full control over error handling and retries.

data/files/rails/mailers/expert/custom_mailer_preview.md

@@ -0,0 +1,18 @@
+## 🖥️ Parameterized Mailer Previews with Locales
+
+Enhance `ActionMailer::Preview` by passing dynamic parameters and locale overrides. This helps stakeholders preview emails in different contexts without code changes.
+
+```ruby
+# test/mailers/previews/user_mailer_preview.rb
+class UserMailerPreview < ActionMailer::Preview
+  # GET /rails/mailers/user_mailer/welcome?user_id=5&locale=es
+  def welcome
+    I18n.with_locale(params[:locale] || :en) do
+      user = User.find(params[:user_id] || User.first.id)
+      UserMailer.with(user: user).welcome_email
+    end
+  end
+end
+```
+
+Navigate to `/rails/mailers/user_mailer/welcome?user_id=42&locale=fr` to verify localized content and bank‑level personalization.

data/files/rails/mailers/expert/dynamic_multipart_variants.md

@@ -0,0 +1,25 @@
+## 📐 Dynamic Multipart Emails with Variants
+
+Build HTML/text emails with on‑the‑fly content variants and inline attachments. Use Rails 6+ variants to generate responsive images or localized screenshots.
+
+```ruby
+# app/mailers/report_mailer.rb
+class ReportMailer < ApplicationMailer
+  def weekly_summary(user)
+    attachments.inline["chart.png"] = generate_chart(user).variant(resize: "600x300").processed.blob
+
+    mail(
+      to: user.email,
+      subject: "Your Weekly Summary",
+      template_path: "report_mailer",
+      template_name: user.premium? ? "premium" : "standard"
+    )
+  end
+end
+
+# app/views/report_mailer/premium.html.erb
+<img src="cid:chart.png" alt="Weekly Chart" />
+<p>Premium features included...</p>
+```
+
+Variants let you tweak attachments without pre‑processing, and dynamic `template_name` switches layouts effortlessly.

data/files/rails/mailers/expert/instrumentation_and_metrics.md

@@ -0,0 +1,15 @@
+## 📊 Fine‑Grained Instrumentation with ActiveSupport::Notifications
+
+Hook into `deliver.action_mailer` and its lifecycle events to gather metrics, custom logs, and traces. This lets you monitor deliver timings, error rates, and queue backpressure.
+
+```ruby
+# config/initializers/mailer_instrumentation.rb
+ActiveSupport::Notifications.subscribe "deliver.action_mailer" do |name, start, finish, id, payload|
+  duration = (finish - start) * 1000.0
+  Rails.logger.info "[Mailer] Delivered #{payload[:mailer]}##{payload[:action]} in #{duration.round(2)}ms to #{payload[:to]}"
+  StatsD.increment("mailer.delivered", tags: ["mailer:#{payload[:mailer]}", "action:#{payload[:action]}"])
+  StatsD.timing("mailer.delivery_time", duration, tags: ["queue:#{payload[:headers]['X-Queue-Name']}"])
+end
+```
+
+With this you can push fine‑grained metrics to Datadog, Prometheus, or any APM, enabling real‑time SLAs for email delivery.

data/files/rails/mailers/expert/mail_interceptors_observers.md

@@ -0,0 +1,30 @@
+## 🔍 Global Mail Interceptors and Observers
+
+Use `ActionMailer::Interceptor` and `Observer` to inject headers, enforce policies, or audit outgoing mails. Interceptors run before delivery; observers run after.
+
+```ruby
+# app/interceptors/add_tracking_header.rb
+class AddTrackingHeader
+  def self.delivering_email(mail)
+    mail.header['X-Tracking-ID'] = SecureRandom.uuid
+  end
+end
+
+# app/observers/email_audit_observer.rb
+class EmailAuditObserver
+  def self.delivered_email(mail)
+    AuditLog.create!(
+      to: mail.to,
+      subject: mail.subject,
+      message_id: mail.message_id,
+      delivered_at: Time.current
+    )
+  end
+end
+
+# config/initializers/mail.rb
+ActionMailer::Base.register_interceptor(AddTrackingHeader)
+ActionMailer::Base.register_observer(EmailAuditObserver)
+```
+
+By combining both, you can mutate outbound messages and capture metadata for compliance and analytics.

data/files/rails/mailers/expert/mailer_concerns_mixins.md

@@ -0,0 +1,32 @@
+## 🧩 Extracting Reusable Mailer Concerns
+
+Encapsulate shared logic—like footers, localization, logging—into mailer concerns. This maintains dry mailers and simplifies changes across multiple mailers.
+
+```ruby
+# app/mailers/concerns/signature_concern.rb
+module SignatureConcern
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_signature
+  end
+
+  private
+
+  def set_signature
+    @signature = current_organization.email_signature
+  end
+end
+
+# app/mailers/application_mailer.rb
+class ApplicationMailer < ActionMailer::Base
+  include SignatureConcern
+  default from: -> { "#{current_organization.name} <no-reply@#{current_organization.domain}>" }
+end
+
+# app/views/user_mailer/welcome.html.erb
+<p>Welcome!</p>
+<p><%= @signature %></p>
+```
+
+Concerns avoid duplication and let you compose behaviors via `include` or `prepend`.

data/files/rails/mailers/expert/prioritized_async_delivery.md

@@ -0,0 +1,25 @@
+## 🚀 Prioritized Asynchronous Delivery
+
+Leverage ActiveJob’s queueing system to schedule emails with different priorities, backoff strategies, and retry limits. By assigning specific queues and priority levels, you can prevent low‑priority batch mails from blocking critical notifications.
+
+```ruby
+# app/mailers/notification_mailer.rb
+class NotificationMailer < ApplicationMailer
+  def urgent_notification(user)
+    mail(to: user.email, subject: "Urgent Update")
+  end
+end
+
+# Enqueue with high priority
+NotificationMailer
+  .urgent_notification(@user)
+  .deliver_later(wait: 1.minute, queue: "critical", priority: 1)
+
+# config/sidekiq.yml
+:queues:
+  - [critical, 10]
+  - [default, 5]
+  - [low_priority, 1]
+```
+
+This approach ensures urgent mails are processed first, while batch jobs fall back to `low_priority` without starving the system.

data/files/rails/mailers/expert/streaming_attachments_s3.md

@@ -0,0 +1,28 @@
+## 📦 Streaming Large Attachments Directly from S3
+
+Avoid loading gigabyte‑scale files into memory by streaming attachments as IO objects. Use `open-uri` with streaming and Tempfile to keep memory footprint low.
+
+```ruby
+# app/mailers/report_mailer.rb
+require 'open-uri'
+class ReportMailer < ApplicationMailer
+  def heavy_report(user)
+    file = Tempfile.new(['report', '.pdf'])
+    URI.open(user.report_url, "rb", &:read) do |stream|
+      IO.copy_stream(stream, file)
+    end
+    file.rewind
+
+    attachments['report.pdf'] = {
+      mime_type: 'application/pdf',
+      content: file.read
+    }
+
+    mail(to: user.email, subject: "Your Heavy Report")
+  ensure
+    file.close!
+  end
+end
+```
+
+This pattern streams directly from S3 (or any HTTP source) without buffering entire payloads in Ruby’s heap.

data/files/rails/mailers/middle/attachments_inline_images.md

@@ -0,0 +1,20 @@
+## 📎 Add Attachments and Inline Images
+
+Attach files or embed images directly in the email body. Inline images improve branding and style consistency in HTML emails.
+
+```ruby
+class InvoiceMailer < ApplicationMailer
+  def invoice_email(invoice)
+    @invoice = invoice
+    attachments['invoice.pdf'] = File.read(invoice.pdf_path)
+    attachments.inline['logo.png'] = File.read(Rails.root.join('app/assets/images/logo.png'))
+    mail(to: @invoice.user.email, subject: 'Your Invoice')
+  end
+end
+```
+
+```erb
+<!-- app/views/invoice_mailer/invoice_email.html.erb -->
+<p>Thank you for your business!</p>
+<img src="cid:logo.png" alt="Company Logo">
+```

data/files/rails/mailers/middle/background_delivery_active_job.md

@@ -0,0 +1,20 @@
+## 🚀 Send Emails Asynchronously with Active Job
+
+Avoid blocking your request-response cycle by sending emails in the background. Use `deliver_later` to enqueue email delivery through Active Job adapters like Sidekiq or Resque.
+
+```ruby
+# app/controllers/orders_controller.rb
+class OrdersController < ApplicationController
+  def create
+    @order = Order.create(order_params)
+    OrderMailer.confirmation(@order).deliver_later(queue: :mailers)
+    redirect_to @order, notice: 'Order placed. Confirmation email is on its way!'
+  end
+end
+```
+
+Configure your queue adapter in `config/environments/production.rb`:
+
+```ruby
+config.active_job.queue_adapter = :sidekiq
+```

data/files/rails/mailers/middle/customizing_layouts.md

@@ -0,0 +1,29 @@
+## 🎨 Customize Mailer Layouts
+
+By default, Rails mailers use `app/views/layouts/mailer.html.erb`. You can define custom layouts per mailer or per action to share wrapping styles and partials across emails. This helps maintain consistent branding and DRY up your templates.
+
+```ruby
+# app/mailers/user_mailer.rb
+class UserMailer < ApplicationMailer
+  layout 'notification'  # uses app/views/layouts/notification.html.erb
+
+  def welcome_email(user)
+    @user = user
+    mail(to: @user.email, subject: 'Welcome!')
+  end
+end
+```
+
+You can even specify a layout per action:
+
+```ruby
+class UserMailer < ApplicationMailer
+  layout :choose_layout
+
+  private
+
+  def choose_layout
+    action_name == 'alert' ? 'alert_layout' : 'mailer'
+  end
+end
+```

data/files/rails/mailers/middle/default_url_options.md

@@ -0,0 +1,12 @@
+## 🔗 Configure default_url_options in Environments
+
+Links in mailers need full URLs (host, protocol). Set `default_url_options` in your environment configs to avoid missing host errors.
+
+```ruby
+# config/environments/development.rb
+Rails.application.routes.default_url_options = { host: 'localhost', port: 3000 }
+# config/environments/production.rb
+Rails.application.routes.default_url_options = { host: 'example.com', protocol: 'https' }
+```
+
+Now helpers like `edit_user_url(@user)` in your mailer views generate absolute URLs automatically.

data/files/rails/mailers/middle/localizing_content.md

@@ -0,0 +1,18 @@
+## 🌐 Localize Mailer Content with I18n
+
+Use Rails I18n to translate subjects, headers, and bodies of your emails. This ensures users receive messages in their preferred language without duplicating templates.
+
+```yaml
+# config/locales/en.yml
+en:
+  user_mailer:
+    reset_password:
+      subject: "Reset your password"
+      greeting: "Hello %{name},"
+```
+
+```erb
+<!-- app/views/user_mailer/reset_password.html.erb -->
+<p><%= t('user_mailer.reset_password.greeting', name: @user.name) %></p>
+<p><%= link_to t('user_mailer.reset_password.link_text'), reset_password_url(@user, token: @token) %></p>
+```

data/files/rails/mailers/middle/mailer_previews.md

@@ -0,0 +1,15 @@
+## 🕵️ Use Mailer Previews for Safe Development
+
+Rails Mailer Previews let you view email templates in the browser without sending real emails. Define previews under `test/mailers/previews` for quick iteration.
+
+```ruby
+# test/mailers/previews/user_mailer_preview.rb
+class UserMailerPreview < ActionMailer::Preview
+  def welcome_email
+    user = User.first || User.new(name: 'Test', email: 'test@example.com')
+    UserMailer.welcome_email(user)
+  end
+end
+```
+
+Visit `http://localhost:3000/rails/mailers/user_mailer/welcome_email` to inspect the email layout and content.

data/files/rails/mailers/middle/testing_mailers.md

@@ -0,0 +1,29 @@
+## 🧪 Test Mailer Methods with ActionMailer::TestHelper
+
+Ensure your mailers generate correct headers, bodies, and attachments. Use `ActionMailer::TestHelper` in your RSpec or Minitest suites.
+
+```ruby
+# spec/mailers/user_mailer_spec.rb
+require 'rails_helper'
+
+RSpec.describe UserMailer, type: :mailer do
+  include ActionMailer::TestHelper
+
+  describe '#welcome_email' do
+    let(:user) { create(:user, email: 'user@example.com') }
+    let(:mail) { UserMailer.welcome_email(user) }
+
+    it 'sends to the correct recipient' do
+      expect(mail.to).to eq(['user@example.com'])
+    end
+
+    it 'includes the correct subject' do
+      expect(mail.subject).to match(/Welcome/)  
+    end
+
+    it 'renders the inline logo' do
+      expect(mail.body.encoded).to include('cid:logo.png')
+    end
+  end
+end
+```

data/files/rails/mailers/middle/using_helpers_in_mailers.md

@@ -0,0 +1,17 @@
+## 🛠️ Leverage View Helpers in Mailers
+
+You can include your view helpers or custom methods in mailers for consistent formatting of data. Simply include or delegate them in your mailer class.
+
+```ruby
+# app/mailers/application_mailer.rb
+class ApplicationMailer < ActionMailer::Base
+  helper ApplicationHelper  # includes all methods from app/helpers/application_helper.rb
+  default from: 'no-reply@example.com'
+  layout 'mailer'
+end
+```
+
+```erb
+<!-- app/views/user_mailer/notification.html.erb -->
+<p>Your balance is <%= number_to_currency(@user.balance) %>.</p>
+```

data/files/rails/middleware/advanced/conditional_middleware_insertion.md

@@ -0,0 +1,17 @@
+## ⚙️ Conditional Middleware Insertion
+Sometimes you only need middleware in specific environments or paths (e.g., monitoring in production). Use `config.middleware.insert_before` or `insert_after` inside environment configs, or wrap registration in a condition to avoid unnecessary overhead.
+
+```ruby
+# config/environments/production.rb
+if ENV['ENABLE_MONITORING'] == 'true'
+  config.middleware.insert_before 0, Rack::Runtime
+  config.middleware.use Monitoring::RequestTracker
+end
+
+# Alternatively, inject only for API routes in an initializer
+Rails.application.config.middleware.insert_after ActionDispatch::Executor do |builder|
+  if Rails.env.production?
+    builder.use ApiRateLimiter, path_prefix: '/api'
+  end
+end
+```

data/files/rails/middleware/advanced/custom_logging_middleware.md

@@ -0,0 +1,26 @@
+## 🛠️ Custom Logging Middleware
+Creating a custom logging middleware lets you capture detailed request and response information without polluting controllers. This approach is useful for auditing, custom metrics, or integrating with external logging services. Implement the `call` method, log before and after the downstream app, and ensure you properly forward the `env` and response.
+
+```ruby
+# app/middleware/custom_logging_middleware.rb
+class CustomLoggingMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    start_time = Time.now
+    Rails.logger.info("[CustomLogger] Started #{env['REQUEST_METHOD']} #{env['PATH_INFO']}")
+
+    status, headers, response = @app.call(env)
+
+    duration = ((Time.now - start_time) * 1000).round(2)
+    Rails.logger.info("[CustomLogger] Completed in #{duration}ms with status #{status}")
+
+    [status, headers, response]
+  end
+end
+
+# config/application.rb
+config.middleware.use CustomLoggingMiddleware
+```

data/files/rails/middleware/advanced/middleware_stack_inspection.md

@@ -0,0 +1,18 @@
+## 🔍 Middleware Stack Inspection and Modification at Runtime
+Advanced debugging may require inspecting or modifying the middleware stack on the fly. Use `Rails.application.middleware` to list, insert, delete, or swap middlewares dynamically, even in a console or during an initializer.
+
+```ruby
+# Inspect current stack
+Rails.application.middleware.each_with_index do |middleware, index|
+  puts "#{index}: #{middleware.klass} (args: #{middleware.args})"
+end
+
+# Remove a middleware
+Rails.application.middleware.delete Rack::Runtime
+
+# Swap two middlewares
+stack = Rails.application.middleware
+runtime_index = stack.index { |m| m.klass == Rack::Runtime }
+logger_index  = stack.index { |m| m.klass == Rails::Rack::Logger }
+stack.swap(runtime_index, logger_index) if runtime_index && logger_index
+```

data/files/rails/middleware/advanced/response_timing_middleware.md

@@ -0,0 +1,28 @@
+## ⏱️ Response Timing and Performance Middleware
+Measure performance at the middleware layer to identify slow requests across your application. You can push metrics to services like Prometheus or StatsD. Use Rack env to tag routes and push histogram metrics.
+
+```ruby
+# app/middleware/response_timing_middleware.rb
+require 'statsd'
+
+class ResponseTimingMiddleware
+  def initialize(app)
+    @app = app
+    @statsd = Statsd.new('localhost', 8125)
+  end
+
+  def call(env)
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    status, headers, response = @app.call(env)
+    duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+
+    route = env['PATH_INFO'].gsub('/', '_').sub(/^_/, '')
+    @statsd.histogram("rails.request.#{route}", duration_ms)
+
+    [status, headers, response]
+  end
+end
+
+# config/application.rb
+config.middleware.use ResponseTimingMiddleware
+```

data/files/rails/middleware/beginner/cors_middleware.md

@@ -0,0 +1,25 @@
+## 🌐 Handling CORS with rack-cors Middleware
+
+To safely allow cross-origin requests (e.g., from your front-end at a different domain), use the `rack-cors` gem. Configure it in Rails to define which origins and HTTP methods are permitted.
+
+```ruby
+# Gemfile
+gem 'rack-cors'
+
+# config/application.rb
+module YourApp
+  class Application < Rails::Application
+    # Insert CORS middleware at the top
+    config.middleware.insert_before 0, Rack::Cors do
+      allow do
+        origins 'https://example.com'
+        resource '/api/*',
+                 headers: :any,
+                 methods: [:get, :post, :put, :delete, :options]
+      end
+    end
+  end
+end
+
+# Now your API routes under /api will accept requests from example.com
+```

data/files/rails/middleware/beginner/custom_middleware_setup.md

@@ -0,0 +1,27 @@
+## 🚀 Creating and Registering Custom Middleware
+
+Custom middleware lets you hook into every request before it reaches your controllers. You define a class with an `initialize` and `call` method, then insert it into the middleware stack. This is perfect for lightweight logging, request transformations, or condition checks.
+
+```ruby
+# lib/my_custom_middleware.rb
+class MyCustomMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    Rails.logger.info "[MyCustomMiddleware] Request Path: #{env['PATH_INFO']}"
+    @app.call(env)
+  end
+end
+
+# config/application.rb
+module YourApp
+  class Application < Rails::Application
+    # Ensure 'lib' is autoloaded
+    config.autoload_paths << Rails.root.join('lib')
+    # Register your middleware
+    config.middleware.use MyCustomMiddleware
+  end
+end
+```

data/files/rails/middleware/beginner/insert_middleware_position.md

@@ -0,0 +1,16 @@
+## 🔀 Inserting Middleware at a Specific Position
+
+By default, `config.middleware.use` appends your middleware to the end of the stack. You can precisely control ordering with `insert_before` or `insert_after`. This helps when you need your middleware to run at a specific stage (e.g., before routing or response compression).
+
+```ruby
+# config/application.rb
+module YourApp
+  class Application < Rails::Application
+    # Insert before Rack::Runtime to run early
+    config.middleware.insert_before Rack::Runtime, MyCustomMiddleware
+
+    # Or insert after ActionDispatch::Static to modify responses
+    config.middleware.insert_after ActionDispatch::Static, MyCustomMiddleware
+  end
+end
+```