claude-code-templates 1.21.11 → 1.21.13

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

@@ -0,0 +1,360 @@
+# Ruby Model Generator
+
+Create Ruby classes and models with proper structure and best practices.
+
+## Purpose
+
+This command helps you quickly create Ruby model classes with proper initialization, attributes, and methods following Ruby conventions.
+
+## Usage
+
+```
+/model
+```
+
+## What this command does
+
+1. **Creates model classes** with proper initialization methods
+2. **Adds attribute accessors** and instance variables
+3. **Includes validation methods** and error handling
+4. **Follows Ruby conventions** and best practices
+5. **Generates related test files** when applicable
+
+## Example Output
+
+```ruby
+# app/models/user.rb
+class User
+  attr_accessor :name, :email, :age
+  attr_reader :id, :created_at
+  
+  def initialize(attributes = {})
+    @id = attributes[:id] || generate_id
+    @name = attributes[:name]
+    @email = attributes[:email]
+    @age = attributes[:age]
+    @created_at = Time.now
+    @errors = []
+  end
+  
+  def valid?
+    @errors.clear
+    validate_presence_of_name
+    validate_email_format
+    validate_age_range
+    @errors.empty?
+  end
+  
+  def errors
+    @errors.dup
+  end
+  
+  def save
+    return false unless valid?
+    
+    # Persist logic here
+    true
+  end
+  
+  def to_h
+    {
+      id: @id,
+      name: @name,
+      email: @email,
+      age: @age,
+      created_at: @created_at
+    }
+  end
+  
+  def to_json(*args)
+    JSON.generate(to_h, *args)
+  end
+  
+  private
+  
+  def validate_presence_of_name
+    if @name.nil? || @name.strip.empty?
+      @errors << "Name cannot be blank"
+    end
+  end
+  
+  def validate_email_format
+    if @email && !@email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+      @errors << "Email format is invalid"
+    end
+  end
+  
+  def validate_age_range
+    if @age && (@age < 0 || @age > 150)
+      @errors << "Age must be between 0 and 150"
+    end
+  end
+  
+  def generate_id
+    SecureRandom.uuid
+  end
+end
+
+# Example with inheritance
+class AdminUser < User
+  attr_accessor :permissions
+  
+  def initialize(attributes = {})
+    super
+    @permissions = attributes[:permissions] || []
+  end
+  
+  def admin?
+    true
+  end
+  
+  def has_permission?(permission)
+    @permissions.include?(permission)
+  end
+  
+  private
+  
+  def validate_permissions
+    unless @permissions.is_a?(Array)
+      @errors << "Permissions must be an array"
+    end
+  end
+end
+```
+
+## Advanced Features
+
+### Module Inclusion
+```ruby
+module Timestamps
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def with_timestamps
+      attr_reader :created_at, :updated_at
+      
+      define_method :initialize do |*args|
+        super(*args)
+        @created_at ||= Time.now
+        @updated_at = @created_at
+      end
+      
+      define_method :touch do
+        @updated_at = Time.now
+      end
+    end
+  end
+end
+
+class Post
+  include Timestamps
+  with_timestamps
+  
+  attr_accessor :title, :content
+  
+  def initialize(attributes = {})
+    @title = attributes[:title]
+    @content = attributes[:content]
+    super
+  end
+end
+```
+
+### Class Methods and Scopes
+```ruby
+class User
+  @@users = []
+  
+  def self.all
+    @@users.dup
+  end
+  
+  def self.find_by_email(email)
+    @@users.find { |user| user.email == email }
+  end
+  
+  def self.where(conditions = {})
+    @@users.select do |user|
+      conditions.all? { |key, value| user.send(key) == value }
+    end
+  end
+  
+  def self.create(attributes = {})
+    user = new(attributes)
+    if user.save
+      @@users << user
+      user
+    else
+      nil
+    end
+  end
+  
+  def save
+    return false unless valid?
+    
+    unless @@users.include?(self)
+      @@users << self
+    end
+    true
+  end
+  
+  def destroy
+    @@users.delete(self)
+  end
+end
+```
+
+## Testing Template
+
+```ruby
+# spec/models/user_spec.rb
+require 'spec_helper'
+
+RSpec.describe User do
+  let(:valid_attributes) do
+    {
+      name: 'John Doe',
+      email: 'john@example.com',
+      age: 30
+    }
+  end
+  
+  describe '#initialize' do
+    it 'sets attributes correctly' do
+      user = User.new(valid_attributes)
+      
+      expect(user.name).to eq('John Doe')
+      expect(user.email).to eq('john@example.com')
+      expect(user.age).to eq(30)
+      expect(user.id).not_to be_nil
+      expect(user.created_at).to be_a(Time)
+    end
+  end
+  
+  describe '#valid?' do
+    it 'returns true for valid attributes' do
+      user = User.new(valid_attributes)
+      expect(user).to be_valid
+    end
+    
+    it 'returns false when name is blank' do
+      user = User.new(valid_attributes.merge(name: ''))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Name cannot be blank')
+    end
+    
+    it 'returns false for invalid email format' do
+      user = User.new(valid_attributes.merge(email: 'invalid-email'))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Email format is invalid')
+    end
+    
+    it 'returns false for invalid age' do
+      user = User.new(valid_attributes.merge(age: -5))
+      expect(user).not_to be_valid
+      expect(user.errors).to include('Age must be between 0 and 150')
+    end
+  end
+  
+  describe '#save' do
+    it 'saves valid user' do
+      user = User.new(valid_attributes)
+      expect(user.save).to be true
+    end
+    
+    it 'does not save invalid user' do
+      user = User.new(name: '')
+      expect(user.save).to be false
+    end
+  end
+  
+  describe '#to_h' do
+    it 'returns hash representation' do
+      user = User.new(valid_attributes)
+      hash = user.to_h
+      
+      expect(hash).to include(
+        name: 'John Doe',
+        email: 'john@example.com',
+        age: 30
+      )
+      expect(hash[:id]).not_to be_nil
+      expect(hash[:created_at]).to be_a(Time)
+    end
+  end
+end
+```
+
+## Best Practices Included
+
+- **Proper initialization** with hash parameters
+- **Attribute accessors** for public attributes
+- **Validation methods** with error collection
+- **JSON serialization** support
+- **Class and instance methods** separation
+- **Error handling** and reporting
+- **Ruby naming conventions** (snake_case)
+- **Encapsulation** with private methods
+
+## Common Patterns
+
+### Value Objects
+```ruby
+class Money
+  include Comparable
+  
+  attr_reader :amount, :currency
+  
+  def initialize(amount, currency = 'USD')
+    @amount = amount.to_f
+    @currency = currency.to_s.upcase
+  end
+  
+  def +(other)
+    raise ArgumentError, "Currency mismatch" unless currency == other.currency
+    Money.new(amount + other.amount, currency)
+  end
+  
+  def <=>(other)
+    raise ArgumentError, "Currency mismatch" unless currency == other.currency
+    amount <=> other.amount
+  end
+  
+  def to_s
+    "#{currency} #{format('%.2f', amount)}"
+  end
+end
+```
+
+### Service Objects
+```ruby
+class UserRegistrationService
+  attr_reader :user, :errors
+  
+  def initialize(user_params)
+    @user_params = user_params
+    @errors = []
+  end
+  
+  def call
+    @user = User.new(@user_params)
+    
+    if @user.valid?
+      @user.save
+      send_welcome_email
+      true
+    else
+      @errors = @user.errors
+      false
+    end
+  end
+  
+  private
+  
+  def send_welcome_email
+    # Email sending logic
+  end
+end
+```