rails_skills 0.1.0

data/lib/generators/rails_skills/skills_library/rails-api-controllers/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: rails-api-controllers
+description: API-only controllers, serialization, authentication, versioning
+version: 1.0.0
+---
+
+# Rails API Controllers
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Base class** | `class Api::V1::PostsController < ActionController::API` |
+| **Render JSON** | `render json: @post, status: :ok` |
+| **Error response** | `render json: { error: "Not found" }, status: :not_found` |
+| **Pagination** | `@posts = Post.page(params[:page]).per(25)` |
+
+## API Controller Structure
+
+```ruby
+module Api
+  module V1
+    class PostsController < ApplicationController
+      def index
+        posts = Post.order(created_at: :desc).page(params[:page])
+        render json: posts
+      end
+
+      def show
+        post = Post.find(params[:id])
+        render json: post
+      end
+
+      def create
+        post = Post.new(post_params)
+
+        if post.save
+          render json: post, status: :created
+        else
+          render json: { errors: post.errors.full_messages }, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        post = Post.find(params[:id])
+
+        if post.update(post_params)
+          render json: post
+        else
+          render json: { errors: post.errors.full_messages }, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        post = Post.find(params[:id])
+        post.destroy
+        head :no_content
+      end
+
+      private
+
+      def post_params
+        params.require(:post).permit(:title, :body, :published)
+      end
+    end
+  end
+end
+```
+
+## API Routing
+
+```ruby
+Rails.application.routes.draw do
+  namespace :api do
+    namespace :v1 do
+      resources :posts
+      resources :users, only: [:index, :show]
+    end
+  end
+end
+```
+
+## Error Handling
+
+```ruby
+module Api
+  class ApplicationController < ActionController::API
+    rescue_from ActiveRecord::RecordNotFound do |e|
+      render json: { error: e.message }, status: :not_found
+    end
+
+    rescue_from ActionController::ParameterMissing do |e|
+      render json: { error: e.message }, status: :bad_request
+    end
+  end
+end
+```
+
+## Best Practices
+
+1. Use API-only base class (`ActionController::API`)
+2. Version your API with namespaces
+3. Return consistent error formats
+4. Use proper HTTP status codes
+5. Paginate list endpoints
+6. Use serializers for complex JSON responses

data/lib/generators/rails_skills/skills_library/rails-controllers/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: rails-controllers
+description: Controller actions, routing, REST conventions, filters, strong parameters
+version: 1.0.0
+---
+
+# Rails Controllers
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Generate** | `rails g controller Posts index show` |
+| **Route** | `resources :posts` |
+| **Filter** | `before_action :set_post, only: [:show, :edit, :update, :destroy]` |
+| **Strong params** | `params.require(:post).permit(:title, :body)` |
+| **Redirect** | `redirect_to @post, notice: "Created!"` |
+| **Render** | `render :new, status: :unprocessable_entity` |
+
+## Controller Structure
+
+```ruby
+class PostsController < ApplicationController
+  before_action :set_post, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @posts = Post.all.order(created_at: :desc)
+  end
+
+  def show; end
+
+  def new
+    @post = Post.new
+  end
+
+  def create
+    @post = Post.new(post_params)
+
+    if @post.save
+      redirect_to @post, notice: "Post created."
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def edit; end
+
+  def update
+    if @post.update(post_params)
+      redirect_to @post, notice: "Post updated."
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @post.destroy
+    redirect_to posts_path, notice: "Post deleted."
+  end
+
+  private
+
+  def set_post
+    @post = Post.find(params[:id])
+  end
+
+  def post_params
+    params.require(:post).permit(:title, :body, :published)
+  end
+end
+```
+
+## Routing
+
+```ruby
+Rails.application.routes.draw do
+  resources :posts
+  resources :posts, only: [:index, :show]
+
+  resources :authors do
+    resources :posts, shallow: true
+  end
+
+  resources :posts do
+    member { post :publish }
+    collection { get :archived }
+  end
+
+  namespace :admin do
+    resources :users
+  end
+end
+```
+
+## Response Formats
+
+```ruby
+respond_to do |format|
+  format.html { redirect_to @post }
+  format.json { render json: @post, status: :created }
+  format.turbo_stream
+end
+```
+
+## Error Handling
+
+```ruby
+class ApplicationController < ActionController::Base
+  rescue_from ActiveRecord::RecordNotFound, with: :not_found
+
+  private
+
+  def not_found
+    render file: Rails.root.join("public/404.html"), status: :not_found
+  end
+end
+```
+
+## Best Practices
+
+1. Keep controllers thin - move logic to models or service objects
+2. Always use strong parameters
+3. Use `before_action` for shared setup
+4. Return proper HTTP status codes
+5. Follow RESTful conventions

data/lib/generators/rails_skills/skills_library/rails-hotwire/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: rails-hotwire
+description: Turbo Drive, Turbo Frames, Turbo Streams, and Stimulus
+version: 1.0.0
+---
+
+# Rails Hotwire
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Turbo Frame** | `<%= turbo_frame_tag "name" do %>` |
+| **Turbo Stream** | `<%= turbo_stream.append "list" do %>` |
+| **Stimulus controller** | `data-controller="toggle"` |
+| **Stimulus action** | `data-action="click->toggle#switch"` |
+| **Stimulus target** | `data-toggle-target="content"` |
+
+## Turbo Frames
+
+```erb
+<%# Wrap content in a frame %>
+<%= turbo_frame_tag "post_#{@post.id}" do %>
+  <h2><%= @post.title %></h2>
+  <%= link_to "Edit", edit_post_path(@post) %>
+<% end %>
+
+<%# Lazy-loaded frame %>
+<%= turbo_frame_tag "comments", src: post_comments_path(@post), loading: :lazy do %>
+  <p>Loading comments...</p>
+<% end %>
+```
+
+## Turbo Streams
+
+```erb
+<%# app/views/posts/create.turbo_stream.erb %>
+<%= turbo_stream.prepend "posts" do %>
+  <%= render @post %>
+<% end %>
+
+<%= turbo_stream.update "flash" do %>
+  <div class="notice">Post created!</div>
+<% end %>
+
+<%# Actions: append, prepend, replace, update, remove, before, after %>
+```
+
+### Broadcasts from Model
+
+```ruby
+class Post < ApplicationRecord
+  after_create_commit { broadcast_prepend_to "posts" }
+  after_update_commit { broadcast_replace_to "posts" }
+  after_destroy_commit { broadcast_remove_to "posts" }
+end
+```
+
+## Stimulus
+
+```javascript
+// app/javascript/controllers/toggle_controller.js
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["content"]
+
+  toggle() {
+    this.contentTarget.classList.toggle("hidden")
+  }
+}
+```
+
+```erb
+<div data-controller="toggle">
+  <button data-action="click->toggle#toggle">Toggle</button>
+  <div data-toggle-target="content">
+    Content here
+  </div>
+</div>
+```
+
+## Best Practices
+
+1. Start with Turbo Drive (enabled by default)
+2. Use Turbo Frames for in-page updates
+3. Use Turbo Streams for multi-element updates
+4. Use Stimulus only when HTML-over-the-wire isn't enough
+5. Keep Stimulus controllers small and focused

data/lib/generators/rails_skills/skills_library/rails-jobs/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: rails-jobs
+description: Active Job patterns, Sidekiq, background processing
+version: 1.0.0
+---
+
+# Rails Background Jobs
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Generate** | `rails g job ProcessOrder` |
+| **Enqueue** | `ProcessOrderJob.perform_later(order)` |
+| **Enqueue later** | `ProcessOrderJob.set(wait: 5.minutes).perform_later(order)` |
+| **Enqueue at** | `ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order)` |
+
+## Job Structure
+
+```ruby
+class ProcessOrderJob < ApplicationJob
+  queue_as :default
+  retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
+  discard_on ActiveJob::DeserializationError
+
+  def perform(order)
+    order.process!
+    OrderMailer.confirmation(order).deliver_later
+  end
+end
+```
+
+## Best Practices
+
+1. Keep jobs idempotent
+2. Pass IDs instead of full objects when possible
+3. Use appropriate queues for different priorities
+4. Handle retries and failures gracefully
+5. Monitor queue depths in production

data/lib/generators/rails_skills/skills_library/rails-models/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: rails-models
+description: ActiveRecord patterns, migrations, validations, callbacks, associations
+version: 1.0.0
+---
+
+# Rails Models (ActiveRecord)
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Generate model** | `rails g model User name:string email:string` |
+| **Migration** | `rails g migration AddAgeToUsers age:integer` |
+| **Validation** | `validates :email, presence: true, uniqueness: true` |
+| **Association** | `has_many :posts, dependent: :destroy` |
+| **Scope** | `scope :active, -> { where(active: true) }` |
+
+## Model Structure
+
+```ruby
+class User < ApplicationRecord
+  # Constants
+  ROLES = %w[admin editor viewer].freeze
+
+  # Associations
+  has_many :posts, dependent: :destroy
+  belongs_to :organization, optional: true
+
+  # Validations
+  validates :email, presence: true, uniqueness: { case_sensitive: false }
+  validates :name, presence: true, length: { minimum: 2, maximum: 100 }
+  validates :role, inclusion: { in: ROLES }
+
+  # Callbacks
+  before_save :normalize_email
+
+  # Scopes
+  scope :active, -> { where(active: true) }
+  scope :recent, -> { order(created_at: :desc) }
+
+  # Enums
+  enum :status, { pending: 0, active: 1, archived: 2 }
+
+  private
+
+  def normalize_email
+    self.email = email.downcase.strip
+  end
+end
+```
+
+## Migrations
+
+```ruby
+class CreateUsers < ActiveRecord::Migration[7.0]
+  def change
+    create_table :users do |t|
+      t.string :name, null: false
+      t.string :email, null: false
+      t.boolean :active, default: true
+      t.references :organization, foreign_key: true
+      t.timestamps
+    end
+
+    add_index :users, :email, unique: true
+  end
+end
+```
+
+## Associations
+
+- `has_many :items, dependent: :destroy`
+- `belongs_to :parent, optional: true`
+- `has_many :tags, through: :taggings`
+- `has_one :profile, dependent: :destroy`
+- `has_many :comments, as: :commentable` (polymorphic)
+
+## Validations
+
+- `validates :field, presence: true`
+- `validates :email, uniqueness: { case_sensitive: false }`
+- `validates :age, numericality: { greater_than: 0 }`
+- `validates :field, length: { minimum: 2, maximum: 100 }`
+- `validates :field, format: { with: /\Apattern\z/ }`
+- `validate :custom_validation_method`
+
+## Queries
+
+```ruby
+User.where(active: true)
+User.where.not(role: "guest")
+User.joins(:posts).where(posts: { published: true })
+User.includes(:posts).order(created_at: :desc)
+User.pluck(:id, :name)
+User.group(:role).count
+```
+
+## Best Practices
+
+1. Add database-level constraints (NOT NULL, unique indexes, foreign keys)
+2. Use `includes` to avoid N+1 queries
+3. Keep callbacks simple, use service objects for complex logic
+4. Use scopes for reusable query fragments
+5. Use concerns to share behavior across models

data/lib/generators/rails_skills/skills_library/rails-views/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: rails-views
+description: ERB templates, layouts, partials, forms, and view helpers
+version: 1.0.0
+---
+
+# Rails Views
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Output** | `<%= @post.title %>` |
+| **Logic** | `<% if condition %>` |
+| **Partial** | `<%= render "shared/header" %>` |
+| **Collection** | `<%= render @posts %>` |
+| **Form** | `<%= form_with model: @post do \|f\| %>` |
+| **Link** | `<%= link_to "Home", root_path %>` |
+
+## Layouts
+
+```erb
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= content_for?(:title) ? yield(:title) : "App" %></title>
+    <%= csrf_meta_tags %>
+    <%= stylesheet_link_tag "application" %>
+    <%= javascript_importmap_tags %>
+  </head>
+  <body>
+    <% flash.each do |type, message| %>
+      <div class="flash flash-<%= type %>"><%= message %></div>
+    <% end %>
+    <%= yield %>
+  </body>
+</html>
+```
+
+## Partials
+
+```erb
+<%# Render a partial %>
+<%= render "post", post: @post %>
+
+<%# Render a collection %>
+<%= render partial: "post", collection: @posts %>
+
+<%# Shorthand for collection %>
+<%= render @posts %>
+```
+
+## Forms
+
+```erb
+<%= form_with model: @post do |f| %>
+  <div>
+    <%= f.label :title %>
+    <%= f.text_field :title %>
+  </div>
+
+  <div>
+    <%= f.label :body %>
+    <%= f.text_area :body %>
+  </div>
+
+  <div>
+    <%= f.label :category_id %>
+    <%= f.collection_select :category_id, Category.all, :id, :name, prompt: "Select" %>
+  </div>
+
+  <%= f.submit %>
+<% end %>
+```
+
+## Helpers
+
+```ruby
+module ApplicationHelper
+  def page_title(title)
+    content_for(:title) { title }
+    content_tag(:h1, title)
+  end
+
+  def active_class(path)
+    current_page?(path) ? "active" : ""
+  end
+end
+```
+
+## Turbo Frames
+
+```erb
+<%= turbo_frame_tag "post_#{@post.id}" do %>
+  <%= render @post %>
+<% end %>
+
+<%= turbo_frame_tag "post", src: post_path(@post), loading: :lazy do %>
+  Loading...
+<% end %>
+```
+
+## Best Practices
+
+1. Keep logic out of views - use helpers or presenters
+2. Use partials for reusable components
+3. Always escape user input (ERB does this by default)
+4. Use `content_for` for flexible layouts
+5. Use Turbo Frames for partial page updates

data/lib/generators/rails_skills/skills_library/rspec-testing/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: rspec-testing
+description: RSpec testing patterns for models, controllers, requests, and system tests
+version: 1.0.0
+---
+
+# RSpec Testing
+
+## Quick Reference
+
+| Pattern | Example |
+|---------|---------|
+| **Run all** | `bundle exec rspec` |
+| **Run file** | `bundle exec rspec spec/models/user_spec.rb` |
+| **Run line** | `bundle exec rspec spec/models/user_spec.rb:15` |
+| **Run tag** | `bundle exec rspec --tag focus` |
+
+## Model Specs
+
+```ruby
+RSpec.describe User, type: :model do
+  describe "validations" do
+    it { is_expected.to validate_presence_of(:email) }
+    it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
+  end
+
+  describe "associations" do
+    it { is_expected.to have_many(:posts).dependent(:destroy) }
+    it { is_expected.to belong_to(:organization).optional }
+  end
+
+  describe "#full_name" do
+    it "returns first and last name" do
+      user = build(:user, first_name: "Jane", last_name: "Doe")
+      expect(user.full_name).to eq("Jane Doe")
+    end
+  end
+end
+```
+
+## Request Specs
+
+```ruby
+RSpec.describe "Posts", type: :request do
+  describe "GET /posts" do
+    it "returns a successful response" do
+      get posts_path
+      expect(response).to have_http_status(:ok)
+    end
+  end
+
+  describe "POST /posts" do
+    let(:valid_params) { { post: { title: "Test", body: "Content" } } }
+
+    it "creates a post" do
+      expect {
+        post posts_path, params: valid_params
+      }.to change(Post, :count).by(1)
+    end
+  end
+end
+```
+
+## System Specs
+
+```ruby
+RSpec.describe "Managing posts", type: :system do
+  before { driven_by(:rack_test) }
+
+  it "allows creating a new post" do
+    visit new_post_path
+    fill_in "Title", with: "My Post"
+    fill_in "Body", with: "Content"
+    click_on "Create Post"
+
+    expect(page).to have_content("Post created")
+    expect(page).to have_content("My Post")
+  end
+end
+```
+
+## Factories (FactoryBot)
+
+```ruby
+FactoryBot.define do
+  factory :user do
+    name { "John Doe" }
+    email { Faker::Internet.email }
+    role { "viewer" }
+
+    trait :admin do
+      role { "admin" }
+    end
+  end
+end
+```
+
+## Best Practices
+
+1. Test behavior, not implementation
+2. Use `let` and `before` for setup, keep `it` blocks focused
+3. Use factories instead of fixtures
+4. Write request specs over controller specs
+5. Use `have_http_status` for response assertions
+6. Keep specs fast - minimize database interactions

data/lib/rails_skills/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RailsSkills
+  class Railtie < ::Rails::Railtie
+    generators do
+      require "generators/rails_skills/install/install_generator"
+      require "generators/rails_skills/skill/skill_generator"
+    end
+  end
+end

data/lib/rails_skills/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsSkills
+  VERSION = "0.1.0"
+end

data/lib/rails_skills.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rails_skills/version"
+require "rails_skills/railtie" if defined?(Rails::Railtie)
+
+module RailsSkills
+  class Error < StandardError; end
+
+  SKILLS_DIR = "skills"
+  CLAUDE_DIR = ".claude"
+  CODEX_DIR = ".codex"
+end