State, Validation, Modules และ Composition

checkout = Checkout.new(calculator: calculator)
checkout.final_total(cart)

attr_reader :balance

private

def validate_positive!(amount)
  raise ArgumentError unless amount.positive?
end

def initialize(calculator:)
  @calculator = calculator
end

# EXAMPLE CODE
# Topic: topic_06_classes_modules_composition
#
# Purpose:
# - This file demonstrates reference implementation for the concept.
# - It should pass tests from the beginning.
# - Read and understand it before solving exercises.

class BankAccount
  attr_reader :balance

  def initialize(balance: 0)
    @balance = balance
  end

  def deposit(amount)
    validate_amount!(amount)
    @balance += amount
  end

  private

  def validate_amount!(amount)
    raise ArgumentError, "amount must be positive" unless amount.positive?
  end
end

# STUDENT TASK (BASIC)
# Topic: topic_06_classes_modules_composition
#
# What to do:
# - Implement or improve the class/methods in this file.
# - Read tests in tests/topic_06_classes_modules_composition_spec.rb under the "basic exercise" examples.
# - Make tests pass without breaking the example/advanced sections.
#
# Expected outcome:
# - You can run this topic tests and see all examples green after implementation.

class Wallet
  attr_reader :balance

  def initialize(balance: 0)
    @balance = balance
  end

  def top_up(amount)
    validate_positive!(amount)
    @balance += amount
  end

  def spend(amount)
    validate_positive!(amount)
    raise ArgumentError, "insufficient balance" if amount > @balance

    @balance -= amount
  end

  private

  def validate_positive!(amount)
    raise ArgumentError, "amount must be positive" unless amount.positive?
  end
end

# STUDENT TASK (ADVANCED)
# Topic: topic_06_classes_modules_composition
#
# Academic purpose:
# - Learn composition as a design choice, not just constructor syntax.
# - See how injected collaborators create simpler, more testable classes.
#
# Real-world use case:
# - Checkout systems rarely calculate totals by themselves.
# - Real applications may delegate to tax calculators, discount engines, or pricing services.
# - Injecting a calculator keeps checkout focused on orchestration rather than pricing policy.
#
# Why Ruby is beautiful here:
# - Keyword-based dependency injection is compact and explicit.
# - The collaborator contract can remain small: in this case, just `total(cart)`.
# - Tests can substitute a double easily, making the design discussion visible.
#
# What to do:
# - Complete the challenge behavior requested by the guide.
# - Focus on why composition improves the design, not only how dependency injection works.
# - Use tests in tests/topic_06_classes_modules_composition_spec.rb under the "advanced exercise" examples.
#
# Expected outcome:
# - Advanced tests pass and you can explain the value of injected collaborators.

class Checkout
  def initialize(calculator:)
    @calculator = calculator
  end

  def final_total(cart)
    @calculator.total(cart)
  end
end

# ANSWER KEY (BASIC)
# Topic: topic_06_classes_modules_composition
#
# Solution idea:
# - The wallet owns the balance state.
# - Both top-up and spend operations reuse the same positivity validation.
# - Spending also checks that the wallet has enough balance before mutating state.

class Wallet
  attr_reader :balance

  def initialize(balance: 0)
    @balance = balance
  end

  def top_up(amount)
    validate_positive!(amount)
    @balance += amount
  end

  def spend(amount)
    validate_positive!(amount)
    raise ArgumentError, "insufficient balance" if amount > @balance

    @balance -= amount
  end

  private

  def validate_positive!(amount)
    raise ArgumentError, "amount must be positive" unless amount.positive?
  end
end

# ANSWER KEY (ADVANCED)
# Topic: topic_06_classes_modules_composition
#
# Solution idea:
# - `Checkout` should not calculate prices by itself.
# - Inject the calculator so checkout stays responsible only for orchestration.
# - The method simply delegates to the collaborator's contract.

class Checkout
  def initialize(calculator:)
    @calculator = calculator
  end

  def final_total(cart)
    @calculator.total(cart)
  end
end

# This spec is your learning companion for topic_06_classes_modules_composition.
#
# How to use this file:
# 1) Run tests and observe failures/successes.
# 2) Keep EXAMPLE specs green from the beginning.
# 3) Implement BASIC exercise until BASIC specs pass.
# 4) Implement ADVANCED exercise and pass edge cases.
#
# Expected final result:
# - All examples in this file pass.
# - You understand both the concept and the implementation tradeoffs.

require_relative "../example"
require_relative "../basic_exercise"
require_relative "../adv_exercise"

RSpec.describe "topic_06_classes_modules_composition" do
  describe "EXAMPLE purpose: understand the reference implementation" do
      it "manages bank account deposits" do
        a = BankAccount.new(balance: 10)
        expect(a.deposit(5)).to eq(15)
        expect { a.deposit(0) }.to raise_error(ArgumentError)
      end
  end

  describe "BASIC EXERCISE purpose: implement the comparable task" do
      it "supports wallet top up and spend validations" do
        w = Wallet.new(balance: 20)
  end

  describe "ADVANCED EXERCISE purpose: solve challenge and edge cases" do
      it "uses composition with injected calculator" do
        calculator = instance_double("PriceCalculator", total: 120)
        checkout = Checkout.new(calculator: calculator)
        expect(checkout.final_total([:item])).to eq(120)
      end
    end
  end
end

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"

exec "${ROOT_DIR}/run_tests.sh" "$(basename "${SCRIPT_DIR}")"