anima-core 0.3.0 → 1.0.1

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

@@ -0,0 +1,136 @@
+# RSpec Matchers: Error/Exception Examples
+# Source: rspec-expectations gem features/built_in_matchers/raise_error.feature,
+#         throw_symbol.feature
+
+# raise_error / raise_exception
+RSpec.describe "raise_error matcher" do
+  describe "basic usage" do
+    it "expects any error" do
+      expect { raise StandardError }.to raise_error
+    end
+
+    it "expects specific error class" do
+      expect { raise ArgumentError }.to raise_error(ArgumentError)
+    end
+
+    it "expects error with message string" do
+      expect { raise "boom" }.to raise_error("boom")
+    end
+
+    it "expects error with message regex" do
+      expect { raise "Something went wrong" }.to raise_error(/wrong/)
+    end
+
+    it "expects class and message" do
+      expect { raise ArgumentError, "invalid" }.to raise_error(ArgumentError, "invalid")
+      expect { raise ArgumentError, "invalid" }.to raise_error(ArgumentError, /inv/)
+    end
+  end
+
+  describe "with_message chain" do
+    it "uses with_message for readability" do
+      expect { raise StandardError, "detailed error" }
+        .to raise_error(StandardError)
+        .with_message(/detailed/)
+    end
+  end
+
+  describe "block form for complex assertions" do
+    it "yields error for inspection" do
+      expect { raise ArgumentError, "bad input" }.to raise_error { |error|
+        expect(error).to be_an(ArgumentError)
+        expect(error.message).to include("bad")
+      }
+    end
+  end
+
+  describe "composed matchers" do
+    it "uses matcher composition" do
+      expect { raise ArgumentError, "invalid value" }.to raise_error(
+        an_instance_of(ArgumentError).and(having_attributes(message: /invalid/))
+      )
+    end
+  end
+
+  describe "negative expectation" do
+    it "expects no error" do
+      expect { 1 + 1 }.not_to raise_error
+    end
+  end
+end
+
+# throw_symbol
+RSpec.describe "throw_symbol matcher" do
+  describe "basic usage" do
+    it "expects any symbol thrown" do
+      expect { throw :done }.to throw_symbol
+    end
+
+    it "expects specific symbol" do
+      expect { throw :abort }.to throw_symbol(:abort)
+    end
+
+    it "expects symbol with value" do
+      expect { throw :result, 42 }.to throw_symbol(:result, 42)
+    end
+  end
+
+  describe "negative expectations" do
+    it "expects nothing thrown" do
+      expect { 1 + 1 }.not_to throw_symbol
+    end
+
+    it "expects different symbol" do
+      expect { throw :foo }.not_to throw_symbol(:bar)
+    end
+  end
+end
+
+# Practical examples
+RSpec.describe PaymentService do
+  subject(:service) { build(:payment_service) }
+
+  describe "#process" do
+    context "with invalid amount" do
+      it "raises ArgumentError" do
+        expect { service.process(amount: -100) }
+          .to raise_error(ArgumentError, /positive/)
+      end
+    end
+
+    context "with invalid currency" do
+      it "raises UnsupportedCurrencyError" do
+        expect { service.process(amount: 100, currency: "XXX") }
+          .to raise_error(UnsupportedCurrencyError)
+          .with_message(/XXX/)
+      end
+    end
+
+    context "when gateway fails" do
+      before { allow(service).to receive(:gateway).and_raise(GatewayError) }
+
+      it "raises PaymentFailedError with cause" do
+        expect { service.process(amount: 100) }.to raise_error { |error|
+          expect(error).to be_a(PaymentFailedError)
+          expect(error.cause).to be_a(GatewayError)
+        }
+      end
+    end
+  end
+end
+
+RSpec.describe "early exit with throw/catch" do
+  describe "batch processor" do
+    subject(:processor) { build(:batch_processor) }
+
+    it "throws :halt on critical error" do
+      expect { processor.process_with_halt_on_error(bad_records) }
+        .to throw_symbol(:halt)
+    end
+
+    it "throws with error details" do
+      expect { processor.process_with_halt_on_error(bad_records) }
+        .to throw_symbol(:halt, a_hash_including(reason: :validation_failed))
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# RSpec Matchers: Output Examples
+# Source: rspec-expectations gem features/built_in_matchers/output.feature
+
+# output to stdout
+RSpec.describe "output matcher - stdout" do
+  describe "any output" do
+    it "expects output to stdout" do
+      expect { print "hello" }.to output.to_stdout
+    end
+
+    it "expects no output" do
+      expect { 1 + 1 }.not_to output.to_stdout
+    end
+  end
+
+  describe "specific output" do
+    it "matches exact string" do
+      expect { print "hello" }.to output("hello").to_stdout
+    end
+
+    it "matches with regex" do
+      expect { puts "Hello, World!" }.to output(/World/).to_stdout
+    end
+  end
+end
+
+# output to stderr
+RSpec.describe "output matcher - stderr" do
+  it "captures stderr" do
+    expect { warn "danger" }.to output.to_stderr
+  end
+
+  it "matches warning message" do
+    expect { warn "danger" }.to output("danger\n").to_stderr
+    expect { warn "danger" }.to output(/danger/).to_stderr
+  end
+end
+
+# output from subprocesses
+RSpec.describe "output matcher - any process" do
+  it "captures subprocess stdout" do
+    expect { system("echo hello") }.to output("hello\n").to_stdout_from_any_process
+  end
+
+  it "captures subprocess stderr" do
+    expect { system("echo error >&2") }.to output("error\n").to_stderr_from_any_process
+  end
+end
+
+# Practical examples
+RSpec.describe Logger do
+  subject(:logger) { build(:logger, output: $stdout) }
+
+  describe "#info" do
+    it "outputs formatted message to stdout" do
+      expect { logger.info("test message") }
+        .to output(/\[INFO\].*test message/).to_stdout
+    end
+  end
+
+  describe "#error" do
+    it "outputs to stderr" do
+      expect { logger.error("critical failure") }
+        .to output(/critical failure/).to_stderr
+    end
+  end
+end
+
+RSpec.describe CLI do
+  subject(:cli) { build(:cli) }
+
+  describe "#run" do
+    context "with --help flag" do
+      it "prints usage to stdout" do
+        expect { cli.run(["--help"]) }
+          .to output(/Usage:/).to_stdout
+      end
+    end
+
+    context "with invalid option" do
+      it "prints error to stderr" do
+        expect { cli.run(["--invalid"]) }
+          .to output(/unknown option/).to_stderr
+      end
+    end
+
+    context "in verbose mode" do
+      it "prints progress information" do
+        expect { cli.run(["--verbose", "process"]) }
+          .to output(/Processing/).to_stdout
+      end
+    end
+  end
+end
+
+RSpec.describe RakeTask do
+  describe "external command execution" do
+    it "captures output from system calls" do
+      expect { system("rake db:migrate") }
+        .to output(/migrated/).to_stdout_from_any_process
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# RSpec Matchers: Predicate Examples
+# Source: rspec-expectations gem features/built_in_matchers/predicates.feature
+
+# be_* - converts to predicate method call
+RSpec.describe "dynamic be_* matchers" do
+  it "calls predicate methods ending in ?" do
+    expect(0).to be_zero           # 0.zero?
+    expect([]).to be_empty         # [].empty?
+    expect(5).to be_positive       # 5.positive?
+    expect(-3).to be_negative      # (-3).negative?
+  end
+
+  it "works with custom predicates" do
+    user = build(:user, status: :active)
+
+    expect(user).to be_active      # user.active?
+    expect(user).not_to be_banned  # !user.banned?
+  end
+
+  it "passes arguments to predicate" do
+    expect(12).to be_multiple_of(3)  # 12.multiple_of?(3)
+  end
+end
+
+# have_* - converts to has_*? method call
+RSpec.describe "dynamic have_* matchers" do
+  it "calls has_*? methods" do
+    expect({ a: 1 }).to have_key(:a)    # {a: 1}.has_key?(:a)
+    expect({ a: 1 }).to have_value(1)   # {a: 1}.has_value?(1)
+  end
+
+  it "works with custom has_*? methods" do
+    order = build(:order, :with_items)
+
+    expect(order).to have_items    # order.has_items?
+    expect(order).to have_discount # order.has_discount?
+  end
+end
+
+# Practical examples with Rails models
+RSpec.describe User do
+  subject(:user) { build(:user) }
+
+  describe "validation predicates" do
+    context "with valid attributes" do
+      it { is_expected.to be_valid }
+    end
+
+    context "without email" do
+      subject(:user) { build(:user, email: nil) }
+
+      it { is_expected.not_to be_valid }
+    end
+  end
+
+  describe "state predicates" do
+    context "when active" do
+      subject(:user) { build(:user, :active) }
+
+      it { is_expected.to be_active }
+      it { is_expected.not_to be_suspended }
+    end
+
+    context "when suspended" do
+      subject(:user) { build(:user, :suspended) }
+
+      it { is_expected.to be_suspended }
+      it { is_expected.not_to be_active }
+    end
+  end
+end
+
+RSpec.describe Order do
+  subject(:order) { build(:order) }
+
+  describe "collection predicates" do
+    context "with items" do
+      subject(:order) { build(:order, :with_items) }
+
+      it { is_expected.to have_items }
+    end
+
+    context "without items" do
+      it { is_expected.not_to have_items }
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# RSpec Matchers: Truthiness Examples
+# Source: rspec-expectations gem features/built_in_matchers/be.feature, exist.feature
+
+# be_truthy - any truthy value
+RSpec.describe "be_truthy matcher" do
+  it "passes for true" do
+    expect(true).to be_truthy
+  end
+
+  it "passes for truthy values" do
+    expect(7).to be_truthy
+    expect("foo").to be_truthy
+    expect([]).to be_truthy      # Empty array is truthy
+    expect(0).to be_truthy       # Zero is truthy in Ruby!
+  end
+
+  it "fails for nil and false" do
+    expect(nil).not_to be_truthy
+    expect(false).not_to be_truthy
+  end
+end
+
+# be_falsey / be_falsy - nil or false only
+RSpec.describe "be_falsey matcher" do
+  it "passes for nil" do
+    expect(nil).to be_falsey
+  end
+
+  it "passes for false" do
+    expect(false).to be_falsey
+    expect(false).to be_falsy  # Alias
+  end
+
+  it "fails for truthy values" do
+    expect(true).not_to be_falsey
+    expect(0).not_to be_falsey   # 0 is truthy!
+    expect("").not_to be_falsey  # Empty string is truthy
+  end
+end
+
+# be_nil - exactly nil
+RSpec.describe "be_nil matcher" do
+  it "passes only for nil" do
+    expect(nil).to be_nil
+  end
+
+  it "fails for false" do
+    expect(false).not_to be_nil
+  end
+end
+
+# be true / be false - exact boolean
+RSpec.describe "exact boolean matchers" do
+  it "requires exact true" do
+    expect(true).to be true
+    expect(1).not_to be true  # Truthy but not true
+  end
+
+  it "requires exact false" do
+    expect(false).to be false
+    expect(nil).not_to be false  # Falsey but not false
+  end
+end
+
+# exist - calls exist? or exists?
+RSpec.describe "exist matcher" do
+  it "checks existence" do
+    # For file-like objects
+    expect(File).to exist("/tmp")
+    expect(File).not_to exist("/nonexistent/path")
+  end
+end
+
+# Practical example: model validations
+RSpec.describe User do
+  subject(:user) { build(:user) }
+
+  describe "#admin?" do
+    context "when user is admin" do
+      subject(:user) { build(:user, :admin) }
+
+      it "returns true" do
+        expect(user.admin?).to be true  # Exact boolean check
+      end
+    end
+
+    context "when user is not admin" do
+      it "returns false" do
+        expect(user.admin?).to be false  # Not just falsey
+      end
+    end
+  end
+
+  describe "#deleted_at" do
+    context "when not deleted" do
+      it "is nil" do
+        expect(user.deleted_at).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# RSpec Matchers: Type/Class Examples
+# Source: rspec-expectations gem features/built_in_matchers/types.feature, respond_to.feature
+
+# be_instance_of - exact class match
+RSpec.describe "be_instance_of matcher" do
+  it "matches exact class only" do
+    expect(17.0).to be_instance_of(Float)
+    expect(17.0).to be_an_instance_of(Float)  # Alias
+  end
+
+  it "does NOT match superclass" do
+    expect(17.0).not_to be_instance_of(Numeric)  # Float < Numeric
+  end
+end
+
+# be_kind_of / be_a - class hierarchy match
+RSpec.describe "be_kind_of matcher" do
+  it "matches actual class" do
+    expect(17.0).to be_kind_of(Float)
+    expect(17.0).to be_a(Float)    # Alias
+    expect(17.0).to be_an(Integer) # Grammatical alias (fails - just for example)
+  end
+
+  it "matches superclass" do
+    expect(17.0).to be_kind_of(Numeric)
+    expect(17.0).to be_a(Object)
+  end
+
+  it "matches included modules" do
+    expect([1, 2, 3]).to be_kind_of(Enumerable)
+  end
+end
+
+# respond_to - interface checking
+RSpec.describe "respond_to matcher" do
+  it "checks method existence" do
+    expect("string").to respond_to(:length)
+    expect("string").to respond_to(:upcase, :downcase)  # Multiple
+    expect("string").not_to respond_to(:foo)
+  end
+
+  it "checks argument count" do
+    expect(7).to respond_to(:zero?).with(0).arguments
+    expect(7).to respond_to(:between?).with(2).arguments
+  end
+
+  it "checks argument range" do
+    # Methods with optional arguments
+    expect([]).to respond_to(:first).with(0..1).arguments
+  end
+
+  it "checks keyword arguments" do
+    service = build(:payment_service)
+
+    expect(service).to respond_to(:process).with_keywords(:amount, :currency)
+    expect(service).to respond_to(:process).with(1).argument.and_keywords(:amount)
+  end
+end
+
+# Practical example: duck typing
+RSpec.describe "exportable object" do
+  subject(:exporter) { build(:csv_exporter) }
+
+  it "implements exportable interface" do
+    expect(exporter).to respond_to(:export).with(1).argument
+    expect(exporter).to respond_to(:headers)
+    expect(exporter).to respond_to(:rows)
+  end
+end
+
+# Practical example: model type checking
+RSpec.describe User do
+  subject(:user) { build(:user) }
+
+  it "is an ApplicationRecord" do
+    expect(user).to be_a(ApplicationRecord)
+  end
+
+  it "includes Authenticatable" do
+    expect(user).to be_kind_of(Authenticatable)
+  end
+end

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

@@ -0,0 +1,147 @@
+# RSpec Matchers: Yield Examples
+# Source: rspec-expectations gem features/built_in_matchers/yield.feature
+
+# NOTE: All yield matchers require a block probe |b|
+
+# yield_control - detects any yield
+RSpec.describe "yield_control matcher" do
+  it "passes when block is yielded to" do
+    expect { |b| 5.tap(&b) }.to yield_control
+  end
+
+  it "fails when block is not yielded to" do
+    expect { |b| "no yield" }.not_to yield_control
+  end
+
+  describe "with counts" do
+    it "specifies exact yield count" do
+      expect { |b| 3.times(&b) }.to yield_control.exactly(3).times
+      expect { |b| 2.times(&b) }.to yield_control.twice
+    end
+
+    it "specifies minimum yields" do
+      expect { |b| 5.times(&b) }.to yield_control.at_least(3).times
+      expect { |b| 5.times(&b) }.to yield_control.at_least(:once)
+    end
+
+    it "specifies maximum yields" do
+      expect { |b| 2.times(&b) }.to yield_control.at_most(5).times
+      expect { |b| 1.times(&b) }.to yield_control.at_most(:twice)
+    end
+  end
+end
+
+# yield_with_no_args - yield without arguments
+RSpec.describe "yield_with_no_args matcher" do
+  it "passes when yielded without arguments" do
+    expect { |b| yield_nothing(&b) }.to yield_with_no_args
+  end
+
+  def yield_nothing
+    yield
+  end
+
+  it "fails when yielded with arguments" do
+    expect { |b| yield_with_value(&b) }.not_to yield_with_no_args
+  end
+
+  def yield_with_value
+    yield 42
+  end
+end
+
+# yield_with_args - yield with specific arguments
+RSpec.describe "yield_with_args matcher" do
+  it "passes for any arguments" do
+    expect { |b| "foo".tap(&b) }.to yield_with_args
+  end
+
+  it "matches exact values" do
+    expect { |b| yield_value(42, &b) }.to yield_with_args(42)
+    expect { |b| yield_values("a", "b", &b) }.to yield_with_args("a", "b")
+  end
+
+  it "matches types (uses ===)" do
+    expect { |b| yield_value(42, &b) }.to yield_with_args(Integer)
+    expect { |b| yield_value("foo", &b) }.to yield_with_args(String)
+  end
+
+  it "matches with regex" do
+    expect { |b| yield_value("foobar", &b) }.to yield_with_args(/bar/)
+  end
+
+  def yield_value(val)
+    yield val
+  end
+
+  def yield_values(*vals)
+    yield(*vals)
+  end
+end
+
+# yield_successive_args - multiple yields with different args
+RSpec.describe "yield_successive_args matcher" do
+  it "matches each yielded value in order" do
+    expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+  end
+
+  it "works with hashes" do
+    expect { |b| { a: 1, b: 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+  end
+
+  it "works with composed matchers" do
+    expect { |b| [1, 2, 3].each(&b) }
+      .to yield_successive_args(a_value < 2, 2, a_value > 2)
+  end
+end
+
+# Practical examples
+RSpec.describe File do
+  describe ".open with block" do
+    it "yields file handle" do
+      expect { |b| File.open("/tmp/test.txt", "w", &b) }
+        .to yield_with_args(an_instance_of(File))
+    end
+  end
+end
+
+RSpec.describe Enumerator do
+  describe "#each_with_index" do
+    it "yields element and index pairs" do
+      enum = %w[a b c].each_with_index
+
+      expect { |b| enum.each(&b) }
+        .to yield_successive_args(["a", 0], ["b", 1], ["c", 2])
+    end
+  end
+end
+
+RSpec.describe "Database transaction" do
+  describe ".transaction" do
+    it "yields control for block execution" do
+      expect { |b| ActiveRecord::Base.transaction(&b) }.to yield_control
+    end
+
+    it "yields without arguments" do
+      expect { |b| ActiveRecord::Base.transaction(&b) }.to yield_with_no_args
+    end
+  end
+end
+
+RSpec.describe BatchProcessor do
+  subject(:processor) { build(:batch_processor) }
+
+  describe "#process_each" do
+    let(:items) { build_list(:item, 3) }
+
+    it "yields each item" do
+      expect { |b| processor.process_each(items, &b) }
+        .to yield_successive_args(*items)
+    end
+
+    it "yields expected number of times" do
+      expect { |b| processor.process_each(items, &b) }
+        .to yield_control.exactly(3).times
+    end
+  end
+end