anima-core 0.3.0 → 1.0.0

data/skills/rspec/examples/factory_bot/traits.rb

@@ -0,0 +1,293 @@
+# FactoryBot: Traits Examples
+# Source: factory_bot gem spec/acceptance/traits_spec.rb
+
+# Traits define reusable attribute groups.
+# Compose traits for flexible test data.
+
+# Basic trait definition
+FactoryBot.define do
+  factory :post do
+    title { "My Post" }
+    body { "Content here" }
+
+    trait :published do
+      published { true }
+      published_at { Time.current }
+    end
+
+    trait :draft do
+      published { false }
+      published_at { nil }
+    end
+
+    trait :featured do
+      featured { true }
+      featured_at { Time.current }
+    end
+
+    trait :with_long_content do
+      body { "A" * 1000 }
+    end
+  end
+end
+
+RSpec.describe "Traits" do
+  describe "basic usage" do
+    let(:published_post) { create(:post, :published) }
+
+    it "applies trait attributes" do
+      expect(published_post.published).to be true
+      expect(published_post.published_at).to be_present
+    end
+  end
+
+  describe "multiple traits" do
+    let(:featured_published) { create(:post, :published, :featured) }
+
+    it "applies all traits" do
+      expect(featured_published.published).to be true
+      expect(featured_published.featured).to be true
+    end
+  end
+
+  describe "traits with attribute overrides" do
+    let(:post) { create(:post, :published, title: "Custom Title") }
+
+    it "applies both trait and explicit override" do
+      expect(post.published).to be true
+      expect(post.title).to eq("Custom Title")
+    end
+  end
+end
+
+# Trait precedence
+FactoryBot.define do
+  factory :user do
+    name { "Default" }
+
+    trait :john do
+      name { "John" }
+    end
+
+    trait :jane do
+      name { "Jane" }
+    end
+  end
+end
+
+RSpec.describe "Trait precedence" do
+  describe "last trait wins" do
+    it "applies traits in order" do
+      user_john_jane = build(:user, :john, :jane)
+      user_jane_john = build(:user, :jane, :john)
+
+      expect(user_john_jane.name).to eq("Jane")
+      expect(user_jane_john.name).to eq("John")
+    end
+  end
+
+  describe "explicit overrides trump traits" do
+    let(:user) { build(:user, :john, name: "Custom") }
+
+    it "uses explicit value" do
+      expect(user.name).to eq("Custom")
+    end
+  end
+end
+
+# Trait composition
+FactoryBot.define do
+  factory :article do
+    title { "Article" }
+
+    trait :published do
+      status { "published" }
+    end
+
+    trait :featured do
+      featured { true }
+    end
+
+    trait :popular do
+      published
+      featured
+      views_count { 1000 }
+    end
+
+    # Child factory with traits
+    factory :popular_article, traits: [:popular]
+  end
+end
+
+RSpec.describe "Trait composition" do
+  describe "traits referencing other traits" do
+    let(:article) { build(:article, :popular) }
+
+    it "includes composed traits" do
+      expect(article.status).to eq("published")
+      expect(article.featured).to be true
+      expect(article.views_count).to eq(1000)
+    end
+  end
+
+  describe "child factory with traits" do
+    let(:popular) { build(:popular_article) }
+
+    it "inherits traits from factory definition" do
+      expect(popular.status).to eq("published")
+      expect(popular.featured).to be true
+    end
+  end
+end
+
+# Enum traits (Rails)
+FactoryBot.define do
+  factory :order do
+    # Assuming: enum status: { pending: 0, processing: 1, shipped: 2, delivered: 3 }
+    # Auto-generated traits: :pending, :processing, :shipped, :delivered
+    customer_name { "Customer" }
+  end
+end
+
+RSpec.describe "Enum traits" do
+  describe "auto-generated enum traits" do
+    it "creates traits for each enum value" do
+      pending_order = build(:order, :pending)
+      shipped_order = build(:order, :shipped)
+
+      expect(pending_order.status).to eq("pending")
+      expect(shipped_order.status).to eq("shipped")
+    end
+  end
+end
+
+# Manual enum traits with traits_for_enum
+FactoryBot.define do
+  factory :task do
+    # Define manually when auto-generation disabled
+    traits_for_enum :priority, {low: 0, medium: 1, high: 2}
+  end
+end
+
+# Global traits
+FactoryBot.define do
+  # Traits defined outside factories are global
+  trait :timestamped do
+    created_at { 1.day.ago }
+    updated_at { Time.current }
+  end
+
+  trait :soft_deleted do
+    deleted_at { Time.current }
+  end
+end
+
+RSpec.describe "Global traits" do
+  FactoryBot.define do
+    factory :record do
+      name { "Record" }
+    end
+  end
+
+  describe "using global traits" do
+    let(:record) { build(:record, :timestamped, :soft_deleted) }
+
+    it "applies global traits to any factory" do
+      expect(record.created_at).to be_present
+      expect(record.deleted_at).to be_present
+    end
+  end
+end
+
+# Traits with callbacks
+FactoryBot.define do
+  factory :user do
+    name { "User" }
+
+    trait :with_posts do
+      after(:create) do |user|
+        create_list(:post, 3, author: user)
+      end
+    end
+
+    trait :activated do
+      after(:build) { |user| user.activate! }
+    end
+
+    trait :confirmed do
+      after(:create) { |user| user.confirm! }
+    end
+  end
+end
+
+RSpec.describe "Traits with callbacks" do
+  describe "trait with after(:create)" do
+    let(:user) { create(:user, :with_posts) }
+
+    it "runs callback when trait applied" do
+      expect(user.posts.count).to eq(3)
+    end
+  end
+
+  describe "callback order with multiple traits" do
+    # Callbacks run in order traits are specified
+    let(:user) { create(:user, :activated, :confirmed) }
+
+    it "executes callbacks in trait order" do
+      expect(user).to be_activated
+      expect(user).to be_confirmed
+    end
+  end
+end
+
+# Traits with transient attributes
+FactoryBot.define do
+  factory :user do
+    name { "User" }
+
+    trait :with_posts do
+      transient do
+        posts_count { 5 }
+      end
+
+      after(:create) do |user, evaluator|
+        create_list(:post, evaluator.posts_count, author: user)
+      end
+    end
+  end
+end
+
+RSpec.describe "Traits with transient attributes" do
+  describe "configurable trait behavior" do
+    let(:user) { create(:user, :with_posts, posts_count: 10) }
+
+    it "uses transient attribute in callback" do
+      expect(user.posts.count).to eq(10)
+    end
+  end
+end
+
+# Traits in associations
+FactoryBot.define do
+  factory :comment do
+    body { "Comment" }
+    association :author, factory: [:user, :admin]
+  end
+
+  factory :post do
+    title { "Post" }
+    association :author, :verified, factory: :user
+  end
+end
+
+RSpec.describe "Traits in associations" do
+  describe "association with trait" do
+    let(:comment) { create(:comment) }
+    let(:post) { create(:post) }
+
+    it "applies traits to associated factory" do
+      expect(comment.author).to be_admin
+      expect(post.author).to be_verified
+    end
+  end
+end

data/skills/rspec/examples/factory_bot/transients.rb

@@ -0,0 +1,229 @@
+# FactoryBot: Transient Attributes Examples
+# Source: factory_bot gem spec/acceptance/transient_attributes_spec.rb
+
+# Transient attributes exist only during factory execution.
+# They're available in attribute definitions and callbacks,
+# but not set on the final object.
+
+# Basic transient attributes
+FactoryBot.define do
+  factory :user do
+    transient do
+      upcased { false }
+      prefix { "" }
+    end
+
+    name { "#{prefix}John Doe" }
+
+    after(:create) do |user, evaluator|
+      user.name.upcase! if evaluator.upcased
+    end
+  end
+end
+
+RSpec.describe "Transient attributes" do
+  describe "in attribute definitions" do
+    let(:user) { build(:user, prefix: "Mr. ") }
+
+    it "uses transient in attribute computation" do
+      expect(user.name).to eq("Mr. John Doe")
+    end
+  end
+
+  describe "in callbacks" do
+    let(:user) { create(:user, upcased: true) }
+
+    it "accesses transient via evaluator" do
+      expect(user.name).to eq("JOHN DOE")
+    end
+  end
+
+  describe "not on final object" do
+    let(:user) { build(:user, upcased: true) }
+
+    it "does not set transient as attribute" do
+      expect(user).not_to respond_to(:upcased)
+      expect(user).not_to respond_to(:prefix)
+    end
+  end
+end
+
+# Transient with attributes_for
+RSpec.describe "Transient with attributes_for" do
+  FactoryBot.define do
+    factory :product do
+      transient do
+        discount { 0 }
+      end
+
+      name { "Product" }
+      price { 100 - discount }
+    end
+  end
+
+  describe "excludes transient from hash" do
+    subject(:attrs) { attributes_for(:product, discount: 20) }
+
+    it "computes attributes using transient" do
+      expect(attrs[:price]).to eq(80)
+    end
+
+    it "excludes transient from result" do
+      expect(attrs).not_to have_key(:discount)
+    end
+  end
+end
+
+# Transient sequences
+FactoryBot.define do
+  factory :numbered_item do
+    transient do
+      sequence(:counter)
+    end
+
+    name { "Item ##{counter}" }
+  end
+end
+
+RSpec.describe "Transient sequences" do
+  describe "sequence in transient block" do
+    let(:items) { build_list(:numbered_item, 3) }
+
+    it "increments across instances" do
+      names = items.map(&:name)
+      expect(names).to eq(["Item #1", "Item #2", "Item #3"])
+    end
+  end
+end
+
+# Transient for dynamic associations
+FactoryBot.define do
+  factory :author do
+    name { "Author" }
+
+    transient do
+      books_count { 0 }
+      published_books_count { 0 }
+    end
+
+    after(:create) do |author, evaluator|
+      create_list(:book, evaluator.books_count, author:)
+      create_list(:book, evaluator.published_books_count, :published, author:)
+    end
+  end
+end
+
+RSpec.describe "Transient for associations" do
+  describe "controlling association count" do
+    let(:author) { create(:author, books_count: 3, published_books_count: 2) }
+
+    it "creates specified associations" do
+      expect(author.books.count).to eq(5)
+      expect(author.books.published.count).to eq(2)
+    end
+  end
+end
+
+# Transient objects
+FactoryBot.define do
+  factory :invoice do
+    transient do
+      customer { build(:customer) }
+    end
+
+    customer_name { customer.name }
+    customer_email { customer.email }
+    customer_id { customer.id }
+  end
+end
+
+RSpec.describe "Transient objects" do
+  describe "using object properties" do
+    let(:vip_customer) { build(:customer, :vip, name: "VIP Corp") }
+    let(:invoice) { build(:invoice, customer: vip_customer) }
+
+    it "extracts properties from transient object" do
+      expect(invoice.customer_name).to eq("VIP Corp")
+      expect(invoice.customer_email).to eq(vip_customer.email)
+    end
+  end
+end
+
+# Transient with defaults
+FactoryBot.define do
+  factory :notification do
+    transient do
+      recipient { nil }
+      send_email { true }
+    end
+
+    user { recipient || association(:user) }
+
+    after(:create) do |notification, evaluator|
+      NotificationMailer.send(notification) if evaluator.send_email
+    end
+  end
+end
+
+RSpec.describe "Transient with defaults" do
+  describe "nil default with fallback" do
+    let(:notification) { create(:notification) }
+    let(:specific_user) { create(:user) }
+    let(:targeted_notification) { create(:notification, recipient: specific_user) }
+
+    it "uses fallback when transient is nil" do
+      expect(notification.user).to be_a(User)
+    end
+
+    it "uses provided value when given" do
+      expect(targeted_notification.user).to eq(specific_user)
+    end
+  end
+
+  describe "boolean transient" do
+    let(:silent_notification) { create(:notification, send_email: false) }
+
+    it "respects boolean transient" do
+      # Email not sent when send_email: false
+      expect(silent_notification).to be_persisted
+    end
+  end
+end
+
+# Transient inheritance
+FactoryBot.define do
+  factory :base_record do
+    transient do
+      metadata { {} }
+    end
+
+    name { "Record" }
+  end
+
+  factory :special_record, parent: :base_record do
+    transient do
+      priority { "normal" }
+    end
+
+    name { "Special #{priority} Record" }
+  end
+end
+
+RSpec.describe "Transient inheritance" do
+  describe "child inherits parent transient" do
+    let(:record) { build(:special_record, metadata: {key: "value"}) }
+
+    it "has access to parent transient" do
+      # metadata from parent is available
+      expect(record.name).to include("Special")
+    end
+  end
+
+  describe "child adds own transient" do
+    let(:urgent) { build(:special_record, priority: "urgent") }
+
+    it "uses child-specific transient" do
+      expect(urgent.name).to eq("Special urgent Record")
+    end
+  end
+end

data/skills/rspec/examples/matchers/change.rb

@@ -0,0 +1,115 @@
+# RSpec Matchers: Change Observation Examples
+# Source: rspec-expectations gem features/built_in_matchers/change.feature
+
+# Basic change detection
+RSpec.describe "change matcher" do
+  describe "block form" do
+    it "detects any change" do
+      counter = 0
+      expect { counter += 1 }.to change { counter }
+    end
+
+    it "detects no change" do
+      value = 5
+      expect { value * 2 }.not_to change { value }
+    end
+  end
+
+  describe "receiver/method form" do
+    it "uses object and method name" do
+      user = build(:user, name: "Alice")
+      expect { user.name = "Bob" }.to change(user, :name)
+    end
+  end
+end
+
+# Chaining methods for specific changes
+RSpec.describe "change with chains" do
+  describe ".by(delta)" do
+    it "specifies exact change amount" do
+      counter = 0
+      expect { counter += 5 }.to change { counter }.by(5)
+    end
+  end
+
+  describe ".from(old).to(new)" do
+    it "specifies before and after values" do
+      value = "old"
+      expect { value = "new" }.to change { value }.from("old").to("new")
+    end
+  end
+
+  describe ".by_at_least(minimum)" do
+    it "specifies minimum change" do
+      counter = 0
+      expect { counter += 5 }.to change { counter }.by_at_least(3)
+    end
+  end
+
+  describe ".by_at_most(maximum)" do
+    it "specifies maximum change" do
+      counter = 0
+      expect { counter += 5 }.to change { counter }.by_at_most(10)
+    end
+  end
+end
+
+# Practical example: database record changes
+RSpec.describe User do
+  describe "#save" do
+    subject(:user) { build(:user) }
+
+    it "increments total count" do
+      expect { user.save }.to change(User, :count).by(1)
+    end
+
+    it "changes persisted status" do
+      expect { user.save }.to change(user, :persisted?).from(false).to(true)
+    end
+  end
+end
+
+RSpec.describe Order do
+  subject(:order) { create(:order, :with_items) }
+
+  describe "#add_item" do
+    let(:item) { build(:item, price: 25) }
+
+    it "increments item count" do
+      expect { order.add_item(item) }.to change { order.items.count }.by(1)
+    end
+
+    it "increases total" do
+      expect { order.add_item(item) }.to change(order, :total).by(25)
+    end
+  end
+
+  describe "#apply_discount" do
+    let(:discount) { build(:discount, percentage: 10) }
+
+    it "decreases total by at least discount percentage" do
+      original = order.total
+      min_decrease = original * 0.10
+
+      expect { order.apply_discount(discount) }
+        .to change(order, :total)
+        .by_at_least(-min_decrease)
+    end
+  end
+end
+
+# Using composed matchers with change
+RSpec.describe "change with composed matchers" do
+  it "combines with be_within for floating point" do
+    value = 0.0
+    expect { value += 1.05 }.to change { value }.by(a_value_within(0.1).of(1.0))
+  end
+
+  it "combines with string matchers" do
+    text = "foo bar"
+    expect { text = "baz qux" }
+      .to change { text }
+      .from(a_string_matching(/foo/))
+      .to(a_string_matching(/baz/))
+  end
+end