claude-code-templates 1.21.0 → 1.21.1

package/cli-tool/templates/ruby/.claude/commands/test.md

@@ -0,0 +1,480 @@
+# Ruby Test Generator
+
+Create comprehensive test files with RSpec or Minitest following Ruby testing best practices.
+
+## Purpose
+
+This command helps you quickly create test files with proper structure, examples, and testing patterns for Ruby applications.
+
+## Usage
+
+```
+/test
+```
+
+## What this command does
+
+1. **Creates test files** with proper structure for RSpec or Minitest
+2. **Includes test examples** for common scenarios
+3. **Sets up test helpers** and support files
+4. **Follows testing conventions** and best practices
+5. **Generates factory/fixture data** when needed
+
+## RSpec Example Output
+
+```ruby
+# spec/models/user_spec.rb
+require 'spec_helper'
+
+RSpec.describe User do
+  let(:user) { build(:user) }
+  let(:valid_attributes) do
+    {
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: 30
+    }
+  end
+  
+  describe 'validations' do
+    it { should validate_presence_of(:name) }
+    it { should validate_presence_of(:email) }
+    it { should validate_uniqueness_of(:email) }
+    it { should validate_numericality_of(:age).is_greater_than(0) }
+    
+    context 'when email format is invalid' do
+      let(:user) { build(:user, email: 'invalid-email') }
+      
+      it 'is not valid' do
+        expect(user).not_to be_valid
+        expect(user.errors[:email]).to include('is invalid')
+      end
+    end
+  end
+  
+  describe 'associations' do
+    it { should have_many(:posts) }
+    it { should have_many(:comments) }
+  end
+  
+  describe 'callbacks' do
+    describe 'before_save' do
+      it 'normalizes email' do
+        user = create(:user, email: 'JOHN@EXAMPLE.COM')
+        expect(user.email).to eq('john@example.com')
+      end
+    end
+  end
+  
+  describe 'instance methods' do
+    describe '#full_name' do
+      let(:user) { build(:user, first_name: 'John', last_name: 'Doe') }
+      
+      it 'returns the full name' do
+        expect(user.full_name).to eq('John Doe')
+      end
+      
+      context 'when last_name is missing' do
+        let(:user) { build(:user, first_name: 'John', last_name: nil) }
+        
+        it 'returns only first_name' do
+          expect(user.full_name).to eq('John')
+        end
+      end
+    end
+    
+    describe '#active?' do
+      context 'when user is active' do
+        let(:user) { build(:user, status: 'active') }
+        
+        it 'returns true' do
+          expect(user.active?).to be true
+        end
+      end
+      
+      context 'when user is inactive' do
+        let(:user) { build(:user, status: 'inactive') }
+        
+        it 'returns false' do
+          expect(user.active?).to be false
+        end
+      end
+    end
+  end
+  
+  describe 'class methods' do
+    describe '.active' do
+      let!(:active_user) { create(:user, status: 'active') }
+      let!(:inactive_user) { create(:user, status: 'inactive') }
+      
+      it 'returns only active users' do
+        expect(User.active).to include(active_user)
+        expect(User.active).not_to include(inactive_user)
+      end
+    end
+    
+    describe '.find_by_email' do
+      let!(:user) { create(:user, email: 'test@example.com') }
+      
+      it 'finds user by email' do
+        found_user = User.find_by_email('test@example.com')
+        expect(found_user).to eq(user)
+      end
+      
+      it 'returns nil when user not found' do
+        found_user = User.find_by_email('nonexistent@example.com')
+        expect(found_user).to be_nil
+      end
+    end
+  end
+  
+  describe 'scopes' do
+    describe '.recent' do
+      let!(:old_user) { create(:user, created_at: 1.year.ago) }
+      let!(:recent_user) { create(:user, created_at: 1.day.ago) }
+      
+      it 'returns users created in the last 30 days' do
+        expect(User.recent).to include(recent_user)
+        expect(User.recent).not_to include(old_user)
+      end
+    end
+  end
+end
+```
+
+## Minitest Example Output
+
+```ruby
+# test/models/user_test.rb
+require 'test_helper'
+
+class UserTest < ActiveSupport::TestCase
+  def setup
+    @user = users(:john)
+    @valid_attributes = {
+      name: 'Jane Doe',
+      email: 'jane@example.com',
+      age: 25
+    }
+  end
+  
+  # Validation tests
+  test 'should not save user without name' do
+    user = User.new(@valid_attributes.except(:name))
+    assert_not user.save
+    assert_includes user.errors[:name], "can't be blank"
+  end
+  
+  test 'should not save user without email' do
+    user = User.new(@valid_attributes.except(:email))
+    assert_not user.save
+    assert_includes user.errors[:email], "can't be blank"
+  end
+  
+  test 'should not save user with invalid email' do
+    user = User.new(@valid_attributes.merge(email: 'invalid-email'))
+    assert_not user.save
+    assert_includes user.errors[:email], 'is invalid'
+  end
+  
+  test 'should not save user with duplicate email' do
+    user1 = User.create!(@valid_attributes)
+    user2 = User.new(@valid_attributes)
+    assert_not user2.save
+    assert_includes user2.errors[:email], 'has already been taken'
+  end
+  
+  test 'should save user with valid attributes' do
+    user = User.new(@valid_attributes)
+    assert user.save
+  end
+  
+  # Association tests
+  test 'should have many posts' do
+    assert_respond_to @user, :posts
+    assert_kind_of ActiveRecord::Associations::CollectionProxy, @user.posts
+  end
+  
+  test 'should have many comments' do
+    assert_respond_to @user, :comments
+  end
+  
+  # Instance method tests
+  test 'full_name should return first and last name' do
+    @user.first_name = 'John'
+    @user.last_name = 'Doe'
+    assert_equal 'John Doe', @user.full_name
+  end
+  
+  test 'full_name should return first name only when last name is missing' do
+    @user.first_name = 'John'
+    @user.last_name = nil
+    assert_equal 'John', @user.full_name
+  end
+  
+  test 'active? should return true for active users' do
+    @user.status = 'active'
+    assert @user.active?
+  end
+  
+  test 'active? should return false for inactive users' do
+    @user.status = 'inactive'
+    assert_not @user.active?
+  end
+  
+  # Class method tests
+  test 'active scope should return only active users' do
+    active_user = User.create!(@valid_attributes.merge(status: 'active'))
+    inactive_user = User.create!(@valid_attributes.merge(
+      email: 'inactive@example.com',
+      status: 'inactive'
+    ))
+    
+    active_users = User.active
+    assert_includes active_users, active_user
+    assert_not_includes active_users, inactive_user
+  end
+  
+  test 'find_by_email should find user by email' do
+    user = User.create!(@valid_attributes)
+    found_user = User.find_by_email(@valid_attributes[:email])
+    assert_equal user, found_user
+  end
+  
+  test 'find_by_email should return nil when user not found' do
+    found_user = User.find_by_email('nonexistent@example.com')
+    assert_nil found_user
+  end
+end
+```
+
+## Controller Test Example
+
+```ruby
+# spec/controllers/users_controller_spec.rb
+require 'rails_helper'
+
+RSpec.describe UsersController, type: :controller do
+  let(:user) { create(:user) }
+  let(:valid_attributes) { attributes_for(:user) }
+  let(:invalid_attributes) { { name: '', email: 'invalid' } }
+  
+  describe 'GET #index' do
+    it 'returns a success response' do
+      get :index
+      expect(response).to be_successful
+    end
+    
+    it 'assigns @users' do
+      user1 = create(:user)
+      user2 = create(:user)
+      get :index
+      expect(assigns(:users)).to match_array([user1, user2])
+    end
+  end
+  
+  describe 'GET #show' do
+    it 'returns a success response' do
+      get :show, params: { id: user.to_param }
+      expect(response).to be_successful
+    end
+    
+    it 'assigns the requested user' do
+      get :show, params: { id: user.to_param }
+      expect(assigns(:user)).to eq(user)
+    end
+  end
+  
+  describe 'POST #create' do
+    context 'with valid parameters' do
+      it 'creates a new User' do
+        expect {
+          post :create, params: { user: valid_attributes }
+        }.to change(User, :count).by(1)
+      end
+      
+      it 'redirects to the created user' do
+        post :create, params: { user: valid_attributes }
+        expect(response).to redirect_to(User.last)
+      end
+    end
+    
+    context 'with invalid parameters' do
+      it 'does not create a new User' do
+        expect {
+          post :create, params: { user: invalid_attributes }
+        }.to change(User, :count).by(0)
+      end
+      
+      it 'renders the new template' do
+        post :create, params: { user: invalid_attributes }
+        expect(response).to render_template(:new)
+      end
+    end
+  end
+  
+  describe 'PUT #update' do
+    context 'with valid parameters' do
+      let(:new_attributes) { { name: 'Updated Name' } }
+      
+      it 'updates the requested user' do
+        put :update, params: { id: user.to_param, user: new_attributes }
+        user.reload
+        expect(user.name).to eq('Updated Name')
+      end
+      
+      it 'redirects to the user' do
+        put :update, params: { id: user.to_param, user: new_attributes }
+        expect(response).to redirect_to(user)
+      end
+    end
+    
+    context 'with invalid parameters' do
+      it 'renders the edit template' do
+        put :update, params: { id: user.to_param, user: invalid_attributes }
+        expect(response).to render_template(:edit)
+      end
+    end
+  end
+  
+  describe 'DELETE #destroy' do
+    it 'destroys the requested user' do
+      user # Create user
+      expect {
+        delete :destroy, params: { id: user.to_param }
+      }.to change(User, :count).by(-1)
+    end
+    
+    it 'redirects to the users list' do
+      delete :destroy, params: { id: user.to_param }
+      expect(response).to redirect_to(users_url)
+    end
+  end
+end
+```
+
+## Factory Configuration
+
+```ruby
+# spec/factories/users.rb
+FactoryBot.define do
+  factory :user do
+    sequence(:name) { |n| "User #{n}" }
+    sequence(:email) { |n| "user#{n}@example.com" }
+    age { rand(18..80) }
+    status { 'active' }
+    
+    trait :inactive do
+      status { 'inactive' }
+    end
+    
+    trait :admin do
+      admin { true }
+    end
+    
+    trait :with_posts do
+      after(:create) do |user|
+        create_list(:post, 3, user: user)
+      end
+    end
+    
+    factory :admin_user, traits: [:admin]
+    factory :inactive_user, traits: [:inactive]
+  end
+end
+```
+
+## Test Helper Configuration
+
+```ruby
+# spec/spec_helper.rb
+require 'simplecov'
+SimpleCov.start 'rails' do
+  add_filter '/spec/'
+  add_filter '/config/'
+  add_filter '/vendor/'
+  
+  add_group 'Controllers', 'app/controllers'
+  add_group 'Models', 'app/models'
+  add_group 'Services', 'app/services'
+  add_group 'Libraries', 'lib'
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.disable_monkey_patching!
+  config.warnings = true
+  
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+  
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+end
+```
+
+## Integration Test Example
+
+```ruby
+# spec/requests/api/users_spec.rb
+require 'rails_helper'
+
+RSpec.describe 'API::Users', type: :request do
+  let(:user) { create(:user) }
+  let(:valid_headers) {
+    { 'Authorization' => "Bearer #{user.auth_token}" }
+  }
+  
+  describe 'GET /api/users' do
+    it 'returns users' do
+      create_list(:user, 3)
+      
+      get '/api/users', headers: valid_headers
+      
+      expect(response).to have_http_status(:ok)
+      expect(JSON.parse(response.body)['users'].size).to eq(3)
+    end
+  end
+  
+  describe 'POST /api/users' do
+    let(:valid_params) do
+      {
+        user: {
+          name: 'New User',
+          email: 'new@example.com'
+        }
+      }
+    end
+    
+    it 'creates a new user' do
+      post '/api/users', params: valid_params, headers: valid_headers
+      
+      expect(response).to have_http_status(:created)
+      expect(JSON.parse(response.body)['user']['name']).to eq('New User')
+    end
+  end
+end
+```
+
+## Best Practices Included
+
+- **Descriptive test names** that explain expected behavior
+- **Proper test organization** with contexts and describes
+- **Factory usage** for test data generation
+- **Mocking and stubbing** for external dependencies
+- **Coverage configuration** with SimpleCov
+- **Test helpers** and shared examples
+- **Request/Integration tests** for API endpoints
+- **Feature tests** for user workflows

package/cli-tool/templates/ruby/.claude/settings.json

@@ -0,0 +1,146 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash",
+      "Edit",
+      "MultiEdit",
+      "Write",
+      "Bash(ruby:*)",
+      "Bash(bundle:*)",
+      "Bash(rails:*)",
+      "Bash(rake:*)",
+      "Bash(rspec:*)",
+      "Bash(rubocop:*)",
+      "Bash(brakeman:*)",
+      "Bash(irb:*)",
+      "Bash(pry:*)",
+      "Bash(gem:*)",
+      "Bash(rbenv:*)",
+      "Bash(rvm:*)",
+      "Bash(kamal:*)",
+      "Bash(git:*)"
+    ],
+    "deny": [
+      "Bash(curl:*)",
+      "Bash(wget:*)",
+      "Bash(rm -rf:*)"
+    ],
+    "defaultMode": "allowEdits"
+  },
+  "env": {
+    "BASH_DEFAULT_TIMEOUT_MS": "60000",
+    "BASH_MAX_OUTPUT_LENGTH": "20000",
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
+    "BUNDLE_PATH": "vendor/bundle",
+    "BUNDLE_JOBS": "4"
+  },
+  "includeCoAuthoredBy": true,
+  "cleanupPeriodDays": 30,
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"No description\")\"' >> ~/.claude/bash-command-log.txt"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"); CONTENT=$(echo $STDIN_JSON | jq -r '.tool_input.content // \"\"); if [[ \"$FILE\" =~ \\.rb$ ]] && echo \"$CONTENT\" | grep -q 'puts\\|p '; then echo 'Warning: puts/p statements should be replaced with proper logging' >&2; exit 2; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" == \"Gemfile\" ]] || [[ \"$FILE\" == \"Gemfile.lock\" ]] || [[ \"$FILE\" =~ gemspec$ ]]; then echo 'Checking for vulnerable gems...'; if command -v bundle >/dev/null 2>&1 && bundle show bundler-audit >/dev/null 2>&1; then bundle audit; elif command -v bundle >/dev/null 2>&1; then echo 'Run: bundle add bundler-audit --group development to enable security audits'; else echo 'Bundler not found for security audit'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.rb$ ]]; then if command -v rubocop >/dev/null 2>&1; then rubocop -A \"$FILE\" 2>/dev/null || echo 'RuboCop auto-correction applied'; elif command -v bundle >/dev/null 2>&1 && bundle show rubocop >/dev/null 2>&1; then bundle exec rubocop -A \"$FILE\" 2>/dev/null || echo 'RuboCop auto-correction applied'; else echo 'RuboCop not available for auto-correction'; fi; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.rb$ ]]; then RESULT=$(if command -v rubocop >/dev/null 2>&1; then rubocop \"$FILE\" 2>&1; elif command -v bundle >/dev/null 2>&1 && bundle show rubocop >/dev/null 2>&1; then bundle exec rubocop \"$FILE\" 2>&1; fi); if [ $? -ne 0 ] && [[ -n \"$RESULT\" ]]; then echo \"RuboCop linting issues found: $RESULT\" >&2; exit 2; fi; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.rb$ && \"$FILE\" != *\"spec/\"* && \"$FILE\" != *\"_spec.rb\" && \"$FILE\" != *\"test/\"* && \"$FILE\" != *\"_test.rb\" ]]; then DIR=$(dirname \"$FILE\"); BASENAME=$(basename \"$FILE\" .rb); for TEST_FILE in \"spec/${BASENAME}_spec.rb\" \"test/${BASENAME}_test.rb\" \"spec/models/${BASENAME}_spec.rb\" \"spec/controllers/${BASENAME}_spec.rb\" \"spec/services/${BASENAME}_spec.rb\"; do if [ -f \"$TEST_FILE\" ]; then echo \"Running tests for $TEST_FILE...\"; if command -v rspec >/dev/null 2>&1; then rspec \"$TEST_FILE\"; elif command -v bundle >/dev/null 2>&1 && bundle show rspec >/dev/null 2>&1; then bundle exec rspec \"$TEST_FILE\"; elif command -v ruby >/dev/null 2>&1; then ruby -Itest \"$TEST_FILE\" 2>/dev/null || echo 'Test runner not available'; fi; break; fi; done; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Claude Code notification: $(date)\" >> ~/.claude/notifications.log"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f Gemfile || -f Rakefile ]] && [[ $(git status --porcelain | grep '\\.rb$') ]]; then echo 'Running RuboCop on changed Ruby files...'; if command -v rubocop >/dev/null 2>&1; then rubocop $(git diff --name-only --diff-filter=ACMR | grep '\\.rb$'); elif command -v bundle >/dev/null 2>&1 && bundle show rubocop >/dev/null 2>&1; then bundle exec rubocop $(git diff --name-only --diff-filter=ACMR | grep '\\.rb$'); else echo 'RuboCop not found for linting'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f Gemfile || -f Rakefile ]] && [[ $(git status --porcelain | grep '\\.rb$') ]]; then echo 'Running security scan with Brakeman...'; if command -v brakeman >/dev/null 2>&1; then brakeman --quiet --no-pager || echo 'Brakeman scan completed with findings'; elif command -v bundle >/dev/null 2>&1 && bundle show brakeman >/dev/null 2>&1; then bundle exec brakeman --quiet --no-pager || echo 'Brakeman scan completed with findings'; else echo 'Brakeman not found for security scanning'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f Gemfile ]]; then echo 'Checking for gem vulnerabilities...'; if command -v bundle >/dev/null 2>&1 && bundle show bundler-audit >/dev/null 2>&1; then bundle audit || echo 'Security audit completed with findings'; else echo 'bundler-audit not found. Run: bundle add bundler-audit --group development'; fi; fi",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}