source_monitor 0.2.0 → 0.3.0

data/.claude/skills/tdd-cycle/SKILL.md

@@ -0,0 +1,359 @@
+---
+name: tdd-cycle
+description: Guides Test-Driven Development workflow with Red-Green-Refactor cycle using Minitest and fixtures. Use when the user wants to implement a feature using TDD, write tests first, follow test-driven practices, or mentions red-green-refactor.
+allowed-tools: Read, Write, Edit, Bash
+---
+
+# TDD Cycle — Minitest + Fixtures
+
+## Project Conventions
+- **Testing:** Minitest + fixtures (NEVER RSpec or FactoryBot)
+- **Components:** ViewComponents for reusable UI (partials OK for simple one-offs)
+- **Authorization:** Pundit policies (deny by default)
+- **Jobs:** Solid Queue, shallow jobs, `_later`/`_now` naming
+- **Frontend:** Hotwire (Turbo + Stimulus) + Tailwind CSS
+- **State:** State-as-records for business state (booleans only for technical flags)
+- **Architecture:** Rich models first, service objects for multi-model orchestration
+- **Routing:** Everything-is-CRUD (new resource over new action)
+- **Quality:** RuboCop (omakase) + Brakeman
+
+## The Cycle
+
+```
+1. RED    → Write a failing test that describes desired behavior
+2. GREEN  → Write the minimum code to pass the test
+3. REFACTOR → Improve code while keeping tests green
+4. REPEAT → Next behavior
+```
+
+## Workflow Checklist
+
+```
+TDD Progress:
+- [ ] Step 1: Understand the requirement
+- [ ] Step 2: Choose test type (model/controller/system/component)
+- [ ] Step 3: Write failing test (RED)
+- [ ] Step 4: Verify test fails correctly
+- [ ] Step 5: Implement minimal code (GREEN)
+- [ ] Step 6: Verify test passes
+- [ ] Step 7: Refactor if needed
+- [ ] Step 8: Verify tests still pass
+```
+
+## Step 1: Requirement Analysis
+
+Before writing any code, understand:
+- What is the expected input?
+- What is the expected output/behavior?
+- What are the edge cases?
+- What errors should be handled?
+
+## Step 2: Choose Test Type
+
+| Test Type | Use For | Location |
+|-----------|---------|----------|
+| Model test | Validations, scopes, instance methods | `test/models/` |
+| Controller test | HTTP flow, authorization, responses | `test/controllers/` |
+| System test | Full user flows with JavaScript | `test/system/` |
+| Service test | Business logic, complex operations | `test/services/` |
+| Query test | Complex queries, correctness | `test/queries/` |
+| Component test | ViewComponent rendering | `test/components/` |
+| Policy test | Pundit authorization rules | `test/policies/` |
+| Job test | Background job behavior | `test/jobs/` |
+| Mailer test | Email content, recipients | `test/mailers/` |
+
+## Step 3: Write Failing Test (RED)
+
+### Model Test Template
+
+```ruby
+# test/models/post_test.rb
+require "test_helper"
+
+class PostTest < ActiveSupport::TestCase
+  setup do
+    @post = posts(:published)
+  end
+
+  test "requires title" do
+    @post.title = nil
+    assert_not @post.valid?
+    assert_includes @post.errors[:title], "can't be blank"
+  end
+
+  test ".recent returns posts in descending order" do
+    recent = posts(:recent)
+    old = posts(:old)
+    assert_equal [recent, old], Post.recent.to_a
+  end
+
+  test "#publish! creates a publication record" do
+    post = posts(:draft)
+    assert_difference "Publication.count", 1 do
+      post.publish!(user: users(:admin))
+    end
+  end
+end
+```
+
+### Controller (Integration) Test Template
+
+```ruby
+# test/controllers/posts_controller_test.rb
+require "test_helper"
+
+class PostsControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @user = users(:one)
+    @post = posts(:one)
+    sign_in_as @user
+  end
+
+  test "should get index" do
+    get posts_url
+    assert_response :success
+  end
+
+  test "should create post" do
+    assert_difference("Post.count") do
+      post posts_url, params: { post: { title: "New Post", body: "Content" } }
+    end
+    assert_redirected_to post_url(Post.last)
+  end
+
+  test "should not create post with invalid params" do
+    assert_no_difference("Post.count") do
+      post posts_url, params: { post: { title: "", body: "" } }
+    end
+    assert_response :unprocessable_entity
+  end
+
+  test "requires authentication" do
+    sign_out
+    get posts_url
+    assert_redirected_to new_session_url
+  end
+end
+```
+
+### Service Test Template
+
+```ruby
+# test/services/orders/create_service_test.rb
+require "test_helper"
+
+class Orders::CreateServiceTest < ActiveSupport::TestCase
+  setup do
+    @user = users(:one)
+    @product = products(:widget)
+    @service = Orders::CreateService.new
+  end
+
+  test "creates order with valid params" do
+    result = @service.call(user: @user, items: [{ product_id: @product.id, quantity: 2 }])
+
+    assert result.success?
+    assert_kind_of Order, result.data
+    assert_equal @user, result.data.user
+  end
+
+  test "returns failure with empty items" do
+    result = @service.call(user: @user, items: [])
+
+    assert result.failure?
+    assert_equal :empty_cart, result.code
+  end
+
+  test "wraps in transaction" do
+    assert_no_difference "Order.count" do
+      @service.call(user: @user, items: [{ product_id: 0, quantity: 1 }])
+    end
+  end
+end
+```
+
+### System Test Template
+
+```ruby
+# test/system/posts_test.rb
+require "application_system_test_case"
+
+class PostsTest < ApplicationSystemTestCase
+  setup do
+    @user = users(:one)
+    sign_in_as @user
+  end
+
+  test "creating a post" do
+    visit new_post_url
+
+    fill_in "Title", with: "My Post"
+    fill_in "Body", with: "Post content here"
+    click_button "Create Post"
+
+    assert_text "Post created successfully"
+    assert_text "My Post"
+  end
+
+  test "shows validation errors" do
+    visit new_post_url
+    click_button "Create Post"
+
+    assert_text "can't be blank"
+  end
+end
+```
+
+### ViewComponent Test Template
+
+```ruby
+# test/components/status_badge_component_test.rb
+require "test_helper"
+
+class StatusBadgeComponentTest < ViewComponent::TestCase
+  test "renders published badge" do
+    render_inline(StatusBadgeComponent.new(status: :published))
+
+    assert_selector ".badge", text: "Published"
+    assert_selector ".bg-green-100"
+  end
+
+  test "renders draft badge" do
+    render_inline(StatusBadgeComponent.new(status: :draft))
+
+    assert_selector ".badge", text: "Draft"
+    assert_selector ".bg-gray-100"
+  end
+end
+```
+
+### Policy Test Template
+
+```ruby
+# test/policies/post_policy_test.rb
+require "test_helper"
+
+class PostPolicyTest < ActiveSupport::TestCase
+  setup do
+    @owner = users(:one)
+    @other = users(:two)
+    @post = posts(:one) # belongs to @owner
+  end
+
+  test "owner can update" do
+    assert PostPolicy.new(@owner, @post).update?
+  end
+
+  test "non-owner cannot update" do
+    assert_not PostPolicy.new(@other, @post).update?
+  end
+
+  test "scope returns only authorized records" do
+    scope = PostPolicy::Scope.new(@owner, Post).resolve
+    assert_includes scope, @post
+  end
+end
+```
+
+## Step 4: Verify Failure
+
+Run the test:
+```bash
+bin/rails test test/models/post_test.rb --verbose
+```
+
+The test MUST fail with a clear error. If it passes immediately, either:
+- The behavior already exists
+- The test isn't testing what you think
+
+## Step 5: Implement (GREEN)
+
+Write the MINIMUM code to pass:
+- No optimization
+- No edge case handling beyond what's tested
+- No refactoring
+- Just make it work
+
+## Step 6: Verify Pass
+
+```bash
+bin/rails test test/models/post_test.rb --verbose
+```
+
+## Step 7: Refactor
+
+Improve code while tests stay green:
+- Extract methods for clarity
+- Improve naming
+- Remove duplication
+- Simplify logic
+
+**Rule:** Make ONE change at a time, run tests after EACH change.
+
+## Step 8: Final Verification
+
+Run all related tests:
+```bash
+bin/rails test
+```
+
+## Fixtures Best Practices
+
+```yaml
+# test/fixtures/posts.yml
+published:
+  title: Published Post
+  body: This is published content
+  user: one
+  created_at: <%= 1.day.ago %>
+
+draft:
+  title: Draft Post
+  body: This is draft content
+  user: one
+
+recent:
+  title: Recent Post
+  body: Recent content
+  user: one
+  created_at: <%= 1.hour.ago %>
+
+old:
+  title: Old Post
+  body: Old content
+  user: two
+  created_at: <%= 1.year.ago %>
+```
+
+**Fixture naming tips:**
+- Use descriptive names: `published`, `draft`, `admin_post`
+- Reference other fixtures by name: `user: one`
+- Use ERB for dynamic values: `<%= Time.current %>`
+
+## Test Helper Patterns
+
+```ruby
+# test/test_helper.rb
+class ActiveSupport::TestCase
+  # Use fixtures for all tests
+  fixtures :all
+
+  # Authentication helper
+  def sign_in_as(user)
+    post session_url, params: { email: user.email, password: "password" }
+  end
+
+  def sign_out
+    delete session_url
+  end
+end
+```
+
+## Anti-Patterns to Avoid
+
+1. **Testing implementation, not behavior** — Test what it does, not how
+2. **Too many assertions per test** — One concept per test
+3. **Brittle tests** — Don't assert exact timestamps or error messages
+4. **Slow tests** — Prefer model tests over system tests when possible
+5. **Skipping the RED step** — Always see it fail first
+6. **Over-mocking** — Use real objects with fixtures when possible

data/.claude/skills/viewcomponent-patterns/SKILL.md

@@ -0,0 +1,333 @@
+---
+name: viewcomponent-patterns
+description: Creates ViewComponents for reusable UI elements with TDD. Use when building reusable UI components, extracting complex partials, creating cards/tables/badges/modals, or when user mentions ViewComponent, components, or reusable UI.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# ViewComponent Patterns for Rails 8
+
+## Overview
+
+ViewComponents are Ruby objects for building reusable, testable view components:
+- Faster than partials (no partial lookup)
+- Unit testable without full request cycle
+- Encapsulate view logic with Ruby
+- Type-safe with explicit interfaces
+
+## TDD Workflow
+
+```
+ViewComponent Progress:
+- [ ] Step 1: Write component test (RED)
+- [ ] Step 2: Run test (fails - no component)
+- [ ] Step 3: Generate component skeleton
+- [ ] Step 4: Implement component
+- [ ] Step 5: Run test (GREEN)
+- [ ] Step 6: Add variants/slots if needed
+```
+
+## Step 1: Component Test (RED)
+
+```ruby
+# test/components/card_component_test.rb
+require "test_helper"
+
+class CardComponentTest < ViewComponent::TestCase
+  test "renders the title" do
+    render_inline(CardComponent.new(title: "Test Title"))
+    assert_selector "h3", text: "Test Title"
+  end
+
+  test "renders content block" do
+    render_inline(CardComponent.new(title: "Title")) { "Card content" }
+    assert_text "Card content"
+  end
+
+  test "renders subtitle when provided" do
+    render_inline(CardComponent.new(title: "Title", subtitle: "Subtitle"))
+    assert_selector "p", text: "Subtitle"
+  end
+
+  test "does not render subtitle element when not provided" do
+    render_inline(CardComponent.new(title: "Title"))
+    assert_no_selector ".subtitle"
+  end
+end
+```
+
+## Step 2-4: Implement Component
+
+### Base Component
+
+```ruby
+# app/components/application_component.rb
+class ApplicationComponent < ViewComponent::Base
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::NumberHelper
+
+  def not_specified_span
+    tag.span(I18n.t("components.common.not_specified"), class: "text-slate-400 italic")
+  end
+end
+```
+
+### Basic Component
+
+```ruby
+# app/components/card_component.rb
+class CardComponent < ApplicationComponent
+  def initialize(title:, subtitle: nil)
+    @title = title
+    @subtitle = subtitle
+  end
+
+  attr_reader :title, :subtitle
+
+  def subtitle?
+    subtitle.present?
+  end
+end
+```
+
+```erb
+<%# app/components/card_component.html.erb %>
+<div class="bg-white rounded-lg shadow p-6">
+  <h3 class="text-lg font-semibold text-slate-900"><%= title %></h3>
+  <% if subtitle? %>
+    <p class="subtitle text-sm text-slate-500"><%= subtitle %></p>
+  <% end %>
+  <div class="mt-4">
+    <%= content %>
+  </div>
+</div>
+```
+
+## Common Patterns
+
+### Pattern 1: Status Badge
+
+```ruby
+# app/components/badge_component.rb
+class BadgeComponent < ApplicationComponent
+  VARIANTS = {
+    success: "bg-green-100 text-green-800",
+    warning: "bg-yellow-100 text-yellow-800",
+    error: "bg-red-100 text-red-800",
+    info: "bg-blue-100 text-blue-800",
+    neutral: "bg-slate-100 text-slate-800"
+  }.freeze
+
+  def initialize(text:, variant: :neutral)
+    @text = text
+    @variant = variant.to_sym
+  end
+
+  def call
+    tag.span(
+      @text,
+      class: "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium #{variant_classes}"
+    )
+  end
+
+  private
+
+  def variant_classes
+    VARIANTS.fetch(@variant, VARIANTS[:neutral])
+  end
+end
+```
+
+Testing:
+
+```ruby
+# test/components/badge_component_test.rb
+require "test_helper"
+
+class BadgeComponentTest < ViewComponent::TestCase
+  test "renders success variant" do
+    render_inline(BadgeComponent.new(text: "Active", variant: :success))
+    assert_selector ".bg-green-100"
+    assert_text "Active"
+  end
+
+  test "renders error variant" do
+    render_inline(BadgeComponent.new(text: "Failed", variant: :error))
+    assert_selector ".bg-red-100"
+  end
+
+  test "defaults to neutral variant" do
+    render_inline(BadgeComponent.new(text: "Unknown"))
+    assert_selector ".bg-slate-100"
+  end
+end
+```
+
+### Pattern 2: Component with Slots
+
+```ruby
+# app/components/card_component.rb
+class CardComponent < ApplicationComponent
+  renders_one :header
+  renders_one :footer
+  renders_many :actions
+
+  def initialize(title: nil)
+    @title = title
+  end
+end
+```
+
+Testing slots:
+
+```ruby
+# test/components/card_component_test.rb
+class CardComponentTest < ViewComponent::TestCase
+  test "renders header slot" do
+    render_inline(CardComponent.new) do |card|
+      card.with_header { "Custom Header" }
+    end
+
+    assert_text "Custom Header"
+  end
+
+  test "renders multiple action slots" do
+    render_inline(CardComponent.new) do |card|
+      card.with_action { "Action 1" }
+      card.with_action { "Action 2" }
+    end
+
+    assert_text "Action 1"
+    assert_text "Action 2"
+  end
+end
+```
+
+### Pattern 3: Collection Component
+
+```ruby
+# app/components/event_card_component.rb
+class EventCardComponent < ApplicationComponent
+  with_collection_parameter :event
+
+  def initialize(event:)
+    @event = event
+  end
+
+  delegate :name, :event_date, :status, to: :@event
+
+  def formatted_date
+    return not_specified_span if event_date.nil?
+    I18n.l(event_date, format: :long)
+  end
+
+  def status_badge
+    render BadgeComponent.new(text: status.humanize, variant: status_variant)
+  end
+
+  private
+
+  def status_variant
+    case status.to_sym
+    when :confirmed then :success
+    when :cancelled then :error
+    when :pending then :warning
+    else :neutral
+    end
+  end
+end
+```
+
+Testing collections:
+
+```ruby
+# test/components/event_card_component_test.rb
+class EventCardComponentTest < ViewComponent::TestCase
+  test "renders single event" do
+    event = events(:one)
+    render_inline(EventCardComponent.new(event: event))
+    assert_text event.name
+  end
+
+  test "renders collection" do
+    events_list = [events(:one), events(:two)]
+    render_inline(EventCardComponent.with_collection(events_list))
+    assert_selector ".event-card", count: 2
+  end
+end
+```
+
+### Pattern 4: Modal Component
+
+```ruby
+# app/components/modal_component.rb
+class ModalComponent < ApplicationComponent
+  renders_one :trigger
+  renders_one :title
+  renders_one :footer
+
+  def initialize(id:, size: :medium)
+    @id = id
+    @size = size
+  end
+
+  def size_classes
+    case @size
+    when :small then "max-w-md"
+    when :medium then "max-w-lg"
+    when :large then "max-w-2xl"
+    when :full then "max-w-full mx-4"
+    end
+  end
+end
+```
+
+## Usage in Views
+
+```erb
+<%# Simple component %>
+<%= render BadgeComponent.new(text: "Active", variant: :success) %>
+
+<%# Component with block %>
+<%= render CardComponent.new(title: "Stats") do %>
+  <p>Content here</p>
+<% end %>
+
+<%# Component with slots %>
+<%= render CardComponent.new do |card| %>
+  <% card.with_header do %>
+    <h2>Header</h2>
+  <% end %>
+  Content
+<% end %>
+
+<%# Collection %>
+<%= render EventCardComponent.with_collection(@events) %>
+```
+
+## Previews (Development)
+
+```ruby
+# test/components/previews/badge_component_preview.rb
+class BadgeComponentPreview < ViewComponent::Preview
+  def success
+    render BadgeComponent.new(text: "Active", variant: :success)
+  end
+
+  def error
+    render BadgeComponent.new(text: "Failed", variant: :error)
+  end
+end
+```
+
+Access at: `http://localhost:3000/rails/view_components`
+
+## Checklist
+
+- [ ] Test written first (RED)
+- [ ] Extends `ApplicationComponent`
+- [ ] Uses slots for flexible content
+- [ ] Variants use constants (Open/Closed)
+- [ ] Tested with different inputs
+- [ ] Collection rendering tested
+- [ ] Preview created for development
+- [ ] All tests GREEN

data/.gitignore

@@ -14,3 +14,4 @@
 /test/lib/tmp/install_generator/config/routes.rb
 /app/assets/builds/*
 !/app/assets/builds/.keep
+!/app/assets/builds/source_monitor/

data/.rubocop.yml

@@ -4,6 +4,8 @@ inherit_gem: { rubocop-rails-omakase: rubocop.yml }
 AllCops:
   Exclude:
     - "test/dummy/db/schema.rb"
+    - "test/tmp/**/*"
+    - "test/lib/tmp/**/*"
 
 # Overwrite or add rules to create your own house style
 #

data/.ruby-version

@@ -1 +1 @@
-3.4.4
+4.0.1