aigroup-workflow 2.1.2 → 2.2.0

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

@@ -1,228 +0,0 @@
-# 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/rails-expert/references/rspec-testing.md

@@ -1,367 +0,0 @@
-# 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