aigroup-workflow 2.1.1 → 2.2.0

package/skills/ruby/rails-expert/references/hotwire-turbo.md

@@ -0,0 +1,228 @@
+# Hotwire & Turbo
+
+## Turbo Drive
+
+Turbo Drive automatically converts link clicks and form submissions into AJAX requests:
+
+```ruby
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  def create
+    @article = Article.new(article_params)
+
+    if @article.save
+      redirect_to @article, notice: "Article created!"
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+end
+```
+
+```erb
+<!-- app/views/articles/new.html.erb -->
+<%= form_with model: @article do |f| %>
+  <%= f.text_field :title %>
+  <%= f.text_area :body %>
+  <%= f.submit %>
+<% end %>
+```
+
+## Turbo Frames
+
+Turbo Frames enable scoped page updates:
+
+```erb
+<!-- app/views/articles/show.html.erb -->
+<%= turbo_frame_tag "article_#{@article.id}" do %>
+  <h1><%= @article.title %></h1>
+  <p><%= @article.body %></p>
+  <%= link_to "Edit", edit_article_path(@article) %>
+<% end %>
+
+<!-- app/views/articles/edit.html.erb -->
+<%= turbo_frame_tag "article_#{@article.id}" do %>
+  <%= form_with model: @article do |f| %>
+    <%= f.text_field :title %>
+    <%= f.text_area :body %>
+    <%= f.submit %>
+  <% end %>
+<% end %>
+```
+
+Lazy loading with Turbo Frames:
+
+```erb
+<%= turbo_frame_tag "expensive_content", src: expensive_content_path, loading: :lazy %>
+```
+
+## Turbo Streams
+
+Real-time updates with Turbo Streams:
+
+```ruby
+# app/controllers/comments_controller.rb
+class CommentsController < ApplicationController
+  def create
+    @comment = @article.comments.create(comment_params)
+
+    respond_to do |format|
+      format.turbo_stream
+      format.html { redirect_to @article }
+    end
+  end
+end
+```
+
+```erb
+<!-- app/views/comments/create.turbo_stream.erb -->
+<%= turbo_stream.append "comments" do %>
+  <%= render @comment %>
+<% end %>
+
+<%= turbo_stream.update "comment_form" do %>
+  <%= render "comments/form", comment: Comment.new %>
+<% end %>
+```
+
+Broadcasting with Action Cable:
+
+```ruby
+# app/models/comment.rb
+class Comment < ApplicationRecord
+  belongs_to :article
+
+  after_create_commit -> { broadcast_append_to article, target: "comments" }
+  after_update_commit -> { broadcast_replace_to article }
+  after_destroy_commit -> { broadcast_remove_to article }
+end
+```
+
+```erb
+<!-- app/views/articles/show.html.erb -->
+<%= turbo_stream_from @article %>
+
+<div id="comments">
+  <%= render @article.comments %>
+</div>
+```
+
+## Stimulus Controllers
+
+JavaScript sprinkles with Stimulus:
+
+```javascript
+// app/javascript/controllers/dropdown_controller.js
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["menu"]
+
+  toggle() {
+    this.menuTarget.classList.toggle("hidden")
+  }
+
+  hide(event) {
+    if (!this.element.contains(event.target)) {
+      this.menuTarget.classList.add("hidden")
+    }
+  }
+}
+```
+
+```erb
+<!-- app/views/shared/_dropdown.html.erb -->
+<div data-controller="dropdown" data-action="click@window->dropdown#hide">
+  <button data-action="dropdown#toggle">Menu</button>
+  <div data-dropdown-target="menu" class="hidden">
+    <a href="#">Item 1</a>
+    <a href="#">Item 2</a>
+  </div>
+</div>
+```
+
+## Form Validation with Stimulus
+
+```javascript
+// app/javascript/controllers/form_validator_controller.js
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["input", "error"]
+
+  validate() {
+    const value = this.inputTarget.value
+
+    if (value.length < 3) {
+      this.errorTarget.textContent = "Must be at least 3 characters"
+      this.inputTarget.classList.add("border-red-500")
+    } else {
+      this.errorTarget.textContent = ""
+      this.inputTarget.classList.remove("border-red-500")
+    }
+  }
+}
+```
+
+## Turbo Stream Actions
+
+Seven core actions:
+
+```ruby
+# append, prepend, replace, update, remove, before, after
+turbo_stream.append "target_id", partial: "item", locals: { item: @item }
+turbo_stream.prepend "target_id", html: content
+turbo_stream.replace "target_id", @item
+turbo_stream.update "target_id", html: "<p>Updated</p>"
+turbo_stream.remove "target_id"
+turbo_stream.before "target_id", partial: "item"
+turbo_stream.after "target_id", partial: "item"
+```
+
+## Progressive Enhancement
+
+Start with working HTML, enhance with Turbo:
+
+```erb
+<!-- Works without JavaScript -->
+<%= form_with model: @article, url: articles_path do |f| %>
+  <%= f.text_field :title %>
+  <%= f.submit %>
+<% end %>
+
+<!-- Enhanced with Turbo Frame -->
+<%= turbo_frame_tag "article_form" do %>
+  <%= form_with model: @article do |f| %>
+    <%= f.text_field :title %>
+    <%= f.submit %>
+  <% end %>
+<% end %>
+```
+
+## Common Patterns
+
+Inline editing:
+
+```erb
+<%= turbo_frame_tag dom_id(@article, :title) do %>
+  <%= link_to @article.title, edit_article_path(@article),
+              data: { turbo_frame: dom_id(@article, :title) } %>
+<% end %>
+```
+
+Modal dialogs:
+
+```erb
+<%= turbo_frame_tag "modal" %>
+
+<%= link_to "Open Modal", new_article_path,
+            data: { turbo_frame: "modal" } %>
+```
+
+## Performance Tips
+
+- Use lazy loading for off-screen frames
+- Debounce Stimulus actions for search/autocomplete
+- Cache Turbo Stream partials
+- Use morphing for minimal DOM updates
+- Minimize frame nesting depth

package/skills/ruby/rails-expert/references/rspec-testing.md

@@ -0,0 +1,367 @@
+# RSpec Testing
+
+## RSpec Setup
+
+```ruby
+# Gemfile
+group :development, :test do
+  gem 'rspec-rails'
+  gem 'factory_bot_rails'
+  gem 'faker'
+end
+
+group :test do
+  gem 'shoulda-matchers'
+  gem 'simplecov', require: false
+  gem 'capybara'
+  gem 'selenium-webdriver'
+end
+
+# spec/rails_helper.rb
+require 'simplecov'
+SimpleCov.start 'rails' do
+  add_filter '/spec/'
+  add_filter '/config/'
+  minimum_coverage 95
+end
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end
+
+# spec/support/shoulda_matchers.rb
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :rails
+  end
+end
+```
+
+## Model Specs
+
+```ruby
+# spec/models/user_spec.rb
+require 'rails_helper'
+
+RSpec.describe User, type: :model do
+  describe "associations" do
+    it { should have_many(:posts).dependent(:destroy) }
+    it { should have_one(:profile).dependent(:destroy) }
+    it { should have_many(:comments) }
+  end
+
+  describe "validations" do
+    it { should validate_presence_of(:email) }
+    it { should validate_uniqueness_of(:email).case_insensitive }
+    it { should validate_length_of(:username).is_at_least(3).is_at_most(50) }
+
+    it "validates email format" do
+      user = build(:user, email: "invalid")
+      expect(user).not_to be_valid
+      expect(user.errors[:email]).to include("is invalid")
+    end
+  end
+
+  describe "callbacks" do
+    it "normalizes email before save" do
+      user = create(:user, email: "USER@EXAMPLE.COM")
+      expect(user.reload.email).to eq("user@example.com")
+    end
+  end
+
+  describe "#full_name" do
+    it "returns first and last name" do
+      user = build(:user, first_name: "John", last_name: "Doe")
+      expect(user.full_name).to eq("John Doe")
+    end
+  end
+
+  describe "scopes" do
+    let!(:active_user) { create(:user, active: true) }
+    let!(:inactive_user) { create(:user, active: false) }
+
+    it "returns only active users" do
+      expect(User.active).to include(active_user)
+      expect(User.active).not_to include(inactive_user)
+    end
+  end
+end
+```
+
+## Request Specs
+
+```ruby
+# spec/requests/posts_spec.rb
+require 'rails_helper'
+
+RSpec.describe "/posts", type: :request do
+  let(:user) { create(:user) }
+  let(:valid_attributes) { { title: "Test Post", body: "Content" } }
+  let(:invalid_attributes) { { title: "", body: "" } }
+
+  before { sign_in user } # Using Devise helper
+
+  describe "GET /index" do
+    it "renders a successful response" do
+      create_list(:post, 3)
+      get posts_url
+      expect(response).to be_successful
+    end
+  end
+
+  describe "GET /show" do
+    it "renders a successful response" do
+      post = create(:post)
+      get post_url(post)
+      expect(response).to be_successful
+    end
+  end
+
+  describe "POST /create" do
+    context "with valid parameters" do
+      it "creates a new Post" do
+        expect {
+          post posts_url, params: { post: valid_attributes }
+        }.to change(Post, :count).by(1)
+      end
+
+      it "redirects to the created post" do
+        post posts_url, params: { post: valid_attributes }
+        expect(response).to redirect_to(post_url(Post.last))
+      end
+    end
+
+    context "with invalid parameters" do
+      it "does not create a new Post" do
+        expect {
+          post posts_url, params: { post: invalid_attributes }
+        }.not_to change(Post, :count)
+      end
+
+      it "renders unprocessable entity response" do
+        post posts_url, params: { post: invalid_attributes }
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+    end
+  end
+
+  describe "PATCH /update" do
+    let(:post_record) { create(:post, user: user) }
+    let(:new_attributes) { { title: "Updated Title" } }
+
+    it "updates the requested post" do
+      patch post_url(post_record), params: { post: new_attributes }
+      post_record.reload
+      expect(post_record.title).to eq("Updated Title")
+    end
+
+    it "redirects to the post" do
+      patch post_url(post_record), params: { post: new_attributes }
+      expect(response).to redirect_to(post_url(post_record))
+    end
+  end
+
+  describe "DELETE /destroy" do
+    it "destroys the requested post" do
+      post_record = create(:post, user: user)
+      expect {
+        delete post_url(post_record)
+      }.to change(Post, :count).by(-1)
+    end
+  end
+end
+```
+
+## System Specs (Feature Tests)
+
+```ruby
+# spec/system/posts_spec.rb
+require 'rails_helper'
+
+RSpec.describe "Posts", type: :system do
+  before do
+    driven_by(:selenium_chrome_headless)
+  end
+
+  let(:user) { create(:user) }
+
+  describe "creating a post" do
+    it "allows user to create a new post" do
+      sign_in user
+      visit new_post_path
+
+      fill_in "Title", with: "My New Post"
+      fill_in "Body", with: "This is the content"
+      click_button "Create Post"
+
+      expect(page).to have_content("Post was successfully created")
+      expect(page).to have_content("My New Post")
+    end
+  end
+
+  describe "editing a post", js: true do
+    it "updates post via Turbo Frame" do
+      post = create(:post, user: user)
+      sign_in user
+      visit post_path(post)
+
+      click_link "Edit"
+      fill_in "Title", with: "Updated Title"
+      click_button "Update Post"
+
+      expect(page).to have_content("Updated Title")
+      expect(page).not_to have_selector("form")
+    end
+  end
+end
+```
+
+## FactoryBot
+
+```ruby
+# spec/factories/users.rb
+FactoryBot.define do
+  factory :user do
+    email { Faker::Internet.email }
+    username { Faker::Internet.username(specifier: 3..50) }
+    password { "Password123!" }
+
+    trait :admin do
+      role { :admin }
+    end
+
+    trait :with_posts do
+      transient do
+        posts_count { 3 }
+      end
+
+      after(:create) do |user, evaluator|
+        create_list(:post, evaluator.posts_count, user: user)
+      end
+    end
+  end
+
+  factory :post do
+    title { Faker::Lorem.sentence }
+    body { Faker::Lorem.paragraph }
+    association :user
+
+    trait :published do
+      published { true }
+      published_at { Time.current }
+    end
+  end
+end
+
+# Usage
+user = create(:user)
+admin = create(:user, :admin)
+user_with_posts = create(:user, :with_posts, posts_count: 5)
+published_post = create(:post, :published)
+```
+
+## Shared Examples
+
+```ruby
+# spec/support/shared_examples/authenticatable.rb
+RSpec.shared_examples "authenticatable" do
+  describe "authentication" do
+    context "when not signed in" do
+      it "redirects to sign in page" do
+        make_request
+        expect(response).to redirect_to(new_user_session_path)
+      end
+    end
+
+    context "when signed in" do
+      before { sign_in create(:user) }
+
+      it "allows access" do
+        make_request
+        expect(response).to be_successful
+      end
+    end
+  end
+end
+
+# Usage in request spec
+RSpec.describe "/admin/posts", type: :request do
+  include_examples "authenticatable" do
+    let(:make_request) { get admin_posts_path }
+  end
+end
+```
+
+## Testing Jobs
+
+```ruby
+# spec/jobs/email_sender_job_spec.rb
+require 'rails_helper'
+
+RSpec.describe EmailSenderJob, type: :job do
+  describe "#perform" do
+    let(:user) { create(:user) }
+
+    it "sends email" do
+      expect {
+        described_class.perform_now(user.id, :welcome)
+      }.to change { ActionMailer::Base.deliveries.count }.by(1)
+    end
+
+    it "enqueues job" do
+      expect {
+        described_class.perform_later(user.id, :welcome)
+      }.to have_enqueued_job(described_class)
+        .with(user.id, :welcome)
+        .on_queue("default")
+    end
+  end
+end
+```
+
+## Testing Mailers
+
+```ruby
+# spec/mailers/user_mailer_spec.rb
+require 'rails_helper'
+
+RSpec.describe UserMailer, type: :mailer do
+  describe "welcome_email" do
+    let(:user) { create(:user) }
+    let(:mail) { UserMailer.welcome_email(user) }
+
+    it "renders the headers" do
+      expect(mail.subject).to eq("Welcome to Our App")
+      expect(mail.to).to eq([user.email])
+      expect(mail.from).to eq(["noreply@example.com"])
+    end
+
+    it "renders the body" do
+      expect(mail.body.encoded).to match(user.username)
+    end
+  end
+end
+```
+
+## Best Practices
+
+- Use `let` and `let!` for DRY specs
+- Use factories, not fixtures
+- One assertion per example when possible
+- Use descriptive test names
+- Test edge cases and error conditions
+- Keep tests fast (use build instead of create when possible)
+- Use `travel_to` for time-dependent tests
+- Mock external API calls