moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-ruby/modules/advanced-patterns.md

@@ -0,0 +1,309 @@
+# Ruby Advanced Patterns
+
+## Sidekiq Background Jobs
+
+Job Definition:
+```ruby
+# app/jobs/process_order_job.rb
+class ProcessOrderJob < ApplicationJob
+  queue_as :default
+  retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
+  discard_on ActiveJob::DeserializationError
+
+  def perform(order_id)
+    order = Order.find(order_id)
+
+    ActiveRecord::Base.transaction do
+      order.process!
+      order.update!(processed_at: Time.current)
+      OrderMailer.confirmation(order).deliver_later
+    end
+  end
+end
+
+# Sidekiq configuration
+# config/initializers/sidekiq.rb
+Sidekiq.configure_server do |config|
+  config.redis = { url: ENV.fetch("REDIS_URL", "redis://localhost:6379/1") }
+end
+
+Sidekiq.configure_client do |config|
+  config.redis = { url: ENV.fetch("REDIS_URL", "redis://localhost:6379/1") }
+end
+```
+
+## ActiveRecord Advanced Patterns
+
+Scopes and Query Objects:
+```ruby
+class Post < ApplicationRecord
+  scope :published, -> { where(published: true) }
+  scope :recent, -> { order(created_at: :desc) }
+  scope :by_author, ->(author) { where(author: author) }
+  scope :search, ->(query) { where("title ILIKE ?", "%#{query}%") }
+
+  # Complex scope with joins
+  scope :with_comments, -> {
+    joins(:comments).group(:id).having("COUNT(comments.id) > 0")
+  }
+
+  # Scope returning specific columns
+  scope :titles_only, -> { select(:id, :title) }
+end
+
+# Query Object
+class PostSearchQuery
+  def initialize(relation = Post.all)
+    @relation = relation
+  end
+
+  def call(params)
+    @relation
+      .then { |r| filter_by_status(r, params[:status]) }
+      .then { |r| filter_by_date(r, params[:start_date], params[:end_date]) }
+      .then { |r| search_by_title(r, params[:query]) }
+      .then { |r| paginate(r, params[:page], params[:per_page]) }
+  end
+
+  private
+
+  def filter_by_status(relation, status)
+    return relation if status.blank?
+    relation.where(status: status)
+  end
+
+  def filter_by_date(relation, start_date, end_date)
+    relation = relation.where("created_at >= ?", start_date) if start_date
+    relation = relation.where("created_at <= ?", end_date) if end_date
+    relation
+  end
+
+  def search_by_title(relation, query)
+    return relation if query.blank?
+    relation.where("title ILIKE ?", "%#{query}%")
+  end
+
+  def paginate(relation, page, per_page)
+    page ||= 1
+    per_page ||= 25
+    relation.limit(per_page).offset((page.to_i - 1) * per_page.to_i)
+  end
+end
+```
+
+## Production Deployment Patterns
+
+Docker Configuration:
+```dockerfile
+# Dockerfile
+FROM ruby:3.3-slim
+
+RUN apt-get update -qq && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    nodejs \
+    npm \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY Gemfile Gemfile.lock ./
+RUN bundle config set --local deployment 'true' && \
+    bundle config set --local without 'development test' && \
+    bundle install
+
+COPY . .
+
+RUN bundle exec rails assets:precompile
+
+ENV RAILS_ENV=production
+ENV RAILS_LOG_TO_STDOUT=true
+
+EXPOSE 3000
+
+CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]
+```
+
+Puma Configuration:
+```ruby
+# config/puma.rb
+workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+threads threads_count, threads_count
+
+preload_app!
+
+port ENV.fetch("PORT") { 3000 }
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+plugin :tmp_restart
+
+on_worker_boot do
+  ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+end
+```
+
+## Advanced ActiveRecord Patterns
+
+Polymorphic Associations:
+```ruby
+class Comment < ApplicationRecord
+  belongs_to :commentable, polymorphic: true
+  belongs_to :user
+end
+
+class Post < ApplicationRecord
+  has_many :comments, as: :commentable, dependent: :destroy
+end
+
+class Image < ApplicationRecord
+  has_many :comments, as: :commentable, dependent: :destroy
+end
+```
+
+Single Table Inheritance (STI):
+```ruby
+class Vehicle < ApplicationRecord
+  validates :brand, presence: true
+end
+
+class Car < Vehicle
+  validates :doors, numericality: { greater_than: 0 }
+end
+
+class Motorcycle < Vehicle
+  validates :engine_cc, numericality: { greater_than: 0 }
+end
+```
+
+## Action Cable Real-Time Features
+
+Channel Implementation:
+```ruby
+# app/channels/notification_channel.rb
+class NotificationChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "notifications:#{current_user.id}"
+  end
+
+  def unsubscribed
+    stop_all_streams
+  end
+end
+
+# Broadcasting notifications
+class NotificationService
+  def self.notify(user, message)
+    ActionCable.server.broadcast(
+      "notifications:#{user.id}",
+      { message: message, timestamp: Time.current.iso8601 }
+    )
+  end
+end
+```
+
+## Performance Optimization
+
+N+1 Query Prevention:
+```ruby
+# Bad: N+1 queries
+User.all.each do |user|
+  puts user.posts.count  # Executes a query for each user
+end
+
+# Good: Eager loading
+User.includes(:posts).each do |user|
+  puts user.posts.size  # Uses preloaded data
+end
+
+# Counter cache for counts
+class Post < ApplicationRecord
+  belongs_to :user, counter_cache: true
+end
+
+# Migration for counter cache
+add_column :users, :posts_count, :integer, default: 0
+```
+
+Database Indexing:
+```ruby
+# migration
+class AddIndexesToPosts < ActiveRecord::Migration[7.2]
+  def change
+    add_index :posts, :user_id
+    add_index :posts, :status
+    add_index :posts, [:status, :published_at]
+    add_index :posts, :title, using: :gin, opclass: :gin_trgm_ops
+  end
+end
+```
+
+## Security Best Practices
+
+Strong Parameters:
+```ruby
+class UsersController < ApplicationController
+  private
+
+  def user_params
+    params.require(:user).permit(:name, :email, :password, :password_confirmation)
+  end
+end
+```
+
+CSRF Protection:
+```ruby
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+end
+```
+
+SQL Injection Prevention:
+```ruby
+# Bad: Direct interpolation
+User.where("email = '#{params[:email]}'")
+
+# Good: Parameterized query
+User.where(email: params[:email])
+User.where("email = ?", params[:email])
+```
+
+## CI/CD Integration
+
+GitHub Actions Workflow:
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Setup database
+        env:
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432/test
+        run: |
+          bundle exec rails db:create db:migrate
+
+      - name: Run tests
+        env:
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432/test
+        run: bundle exec rspec
+```

moai_adk/templates/.claude/skills/moai-lang-ruby/modules/testing-patterns.md

@@ -0,0 +1,306 @@
+# Ruby Testing Patterns
+
+## RSpec Model Specs
+
+Complete Model Testing:
+```ruby
+# spec/models/user_spec.rb
+RSpec.describe User, type: :model do
+  describe "associations" do
+    it { is_expected.to have_many(:posts).dependent(:destroy) }
+    it { is_expected.to have_one(:profile).dependent(:destroy) }
+  end
+
+  describe "validations" do
+    subject { build(:user) }
+
+    it { is_expected.to validate_presence_of(:email) }
+    it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
+    it { is_expected.to validate_length_of(:name).is_at_least(2).is_at_most(100) }
+  end
+
+  describe "scopes" do
+    describe ".active" do
+      let!(:active_user) { create(:user, active: true) }
+      let!(:inactive_user) { create(:user, active: false) }
+
+      it "returns only active users" do
+        expect(described_class.active).to contain_exactly(active_user)
+      end
+    end
+  end
+
+  describe "#full_name" do
+    context "when both names are present" 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
+    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
+end
+```
+
+## RSpec Request Specs
+
+API Testing:
+```ruby
+# spec/requests/posts_spec.rb
+RSpec.describe "Posts", type: :request do
+  let(:user) { create(:user) }
+
+  before { sign_in user }
+
+  describe "GET /posts" do
+    let!(:posts) { create_list(:post, 3, user: user) }
+
+    it "returns a successful response" do
+      get posts_path
+      expect(response).to have_http_status(:ok)
+    end
+
+    it "displays all posts" do
+      get posts_path
+      posts.each do |post|
+        expect(response.body).to include(post.title)
+      end
+    end
+  end
+
+  describe "POST /posts" do
+    let(:valid_params) { { post: attributes_for(:post) } }
+    let(:invalid_params) { { post: { title: "" } } }
+
+    context "with valid parameters" do
+      it "creates a new post" do
+        expect {
+          post posts_path, params: valid_params
+        }.to change(Post, :count).by(1)
+      end
+
+      it "redirects to the created post" do
+        post posts_path, params: valid_params
+        expect(response).to redirect_to(Post.last)
+      end
+    end
+
+    context "with invalid parameters" do
+      it "does not create a new post" do
+        expect {
+          post posts_path, params: invalid_params
+        }.not_to change(Post, :count)
+      end
+
+      it "returns unprocessable entity status" do
+        post posts_path, params: invalid_params
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+    end
+  end
+end
+```
+
+## Factory Bot Patterns
+
+Advanced Factories:
+```ruby
+# spec/factories/users.rb
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    name { Faker::Name.name }
+    password { "password123" }
+    active { true }
+
+    trait :inactive do
+      active { false }
+    end
+
+    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
+
+    factory :admin_user, traits: [:admin]
+  end
+end
+
+# spec/factories/posts.rb
+FactoryBot.define do
+  factory :post do
+    sequence(:title) { |n| "Post Title #{n}" }
+    content { Faker::Lorem.paragraphs(number: 3).join("\n\n") }
+    user
+    published { false }
+
+    trait :published do
+      published { true }
+      published_at { Time.current }
+    end
+
+    trait :with_comments do
+      transient do
+        comments_count { 5 }
+      end
+
+      after(:create) do |post, evaluator|
+        create_list(:comment, evaluator.comments_count, post: post)
+      end
+    end
+  end
+end
+```
+
+## System Specs with Capybara
+
+End-to-End Testing:
+```ruby
+# spec/system/user_registration_spec.rb
+RSpec.describe "User Registration", type: :system do
+  before do
+    driven_by(:selenium_chrome_headless)
+  end
+
+  it "allows a user to register" do
+    visit new_user_registration_path
+
+    fill_in "Email", with: "newuser@example.com"
+    fill_in "Password", with: "password123"
+    fill_in "Password confirmation", with: "password123"
+    click_button "Sign up"
+
+    expect(page).to have_content("Welcome! You have signed up successfully.")
+    expect(User.find_by(email: "newuser@example.com")).to be_present
+  end
+
+  it "shows validation errors for invalid input" do
+    visit new_user_registration_path
+
+    fill_in "Email", with: "invalid-email"
+    click_button "Sign up"
+
+    expect(page).to have_content("Email is invalid")
+  end
+end
+```
+
+## Service Object Testing
+
+Testing Service Layer:
+```ruby
+# spec/services/user_registration_service_spec.rb
+RSpec.describe UserRegistrationService do
+  describe "#call" do
+    let(:valid_params) do
+      {
+        name: "John Doe",
+        email: "john@example.com",
+        password: "password123"
+      }
+    end
+
+    context "with valid parameters" do
+      it "creates a user" do
+        result = described_class.new(valid_params).call
+
+        expect(result.success?).to be true
+        expect(result.user).to be_persisted
+      end
+
+      it "creates a profile for the user" do
+        result = described_class.new(valid_params).call
+
+        expect(result.user.profile).to be_present
+      end
+
+      it "sends a welcome email" do
+        expect {
+          described_class.new(valid_params).call
+        }.to have_enqueued_mail(UserMailer, :welcome)
+      end
+    end
+
+    context "with invalid parameters" do
+      let(:invalid_params) { { email: "invalid" } }
+
+      it "returns a failure result" do
+        result = described_class.new(invalid_params).call
+
+        expect(result.failure?).to be true
+        expect(result.errors).to be_present
+      end
+
+      it "does not create a user" do
+        expect {
+          described_class.new(invalid_params).call
+        }.not_to change(User, :count)
+      end
+    end
+  end
+end
+```
+
+## Shared Examples
+
+Reusable Test Patterns:
+```ruby
+# spec/support/shared_examples/api_resource.rb
+RSpec.shared_examples "an API resource" do
+  it "returns JSON content type" do
+    expect(response.content_type).to include("application/json")
+  end
+
+  it "returns a successful response" do
+    expect(response).to have_http_status(:ok)
+  end
+end
+
+# Usage in specs
+RSpec.describe "Users API", type: :request do
+  describe "GET /api/users" do
+    before { get api_users_path }
+
+    it_behaves_like "an API resource"
+  end
+end
+```
+
+## Mocking and Stubbing
+
+External Service Mocking:
+```ruby
+RSpec.describe PaymentService do
+  describe "#charge" do
+    let(:payment_gateway) { instance_double(Stripe::PaymentIntent) }
+
+    before do
+      allow(Stripe::PaymentIntent).to receive(:create).and_return(payment_gateway)
+      allow(payment_gateway).to receive(:status).and_return("succeeded")
+    end
+
+    it "processes the payment successfully" do
+      result = described_class.new.charge(amount: 1000, customer_id: "cus_123")
+
+      expect(result).to be_success
+    end
+  end
+end
+```