claude-code-templates 1.16.1 → 1.17.0

package/templates/ruby/.claude/commands/test.md

@@ -1,480 +0,0 @@
-# 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/templates/ruby/.claude/settings.json

@@ -1,146 +0,0 @@
-{
-  "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
-          }
-        ]
-      }
-    ]
-  }
-}