API ที่ยืดหยุ่นด้วย Keyword Arguments และ Blocks

formatter.wrap("warning", left: "(", right: ")")

notifier.notify_all(users) do |message|
  audit_log << message
end

def greet(name, punctuation: "!")
  "Hello, #{name}#{punctuation}"
end

greet("Mina")
greet("Mina", punctuation: ".")

def notify_all(users)
  users.each { |user| yield "Notify #{user}" }
end

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

class Greeter
  def greet(name, punctuation: "!")
    "Hello, #{name}#{punctuation}"
  end

  def greet_many(names)
    names.map { |name| greet(name) }
  end
end

# STUDENT TASK (BASIC)
# Topic: topic_02_methods_keywords_blocks
#
# What to do:
# - Implement or improve the class/methods in this file.
# - Read tests in tests/topic_02_methods_keywords_blocks_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 Formatter
  def wrap(text, left: "[", right: "]")
    "#{left}#{text}#{right}"
  end
end

# STUDENT TASK (ADVANCED)
# Topic: topic_02_methods_keywords_blocks
#
# Academic purpose:
# - Study blocks as a lightweight form of behavior injection.
# - Contrast Ruby's block style with heavier callback abstractions common in Java.
#
# Real-world use case:
# - Notification systems often own the list of users but let the caller decide what to do
#   with each message: log it, enqueue it, send it, or collect it for later.
# - A block is useful when the framework controls iteration and the caller controls the side effect.
#
# Why Ruby is beautiful here:
# - The method can stay tiny while remaining flexible.
# - Callers can customize behavior without defining a new class.
# - The code reads close to the problem statement: "for each user, do this".
#
# What to do:
# - Complete the challenge behavior requested by the guide.
# - Focus on what the block buys you in API design, not just how `yield` works.
# - Use tests in tests/topic_02_methods_keywords_blocks_spec.rb under the "advanced exercise" examples.
#
# Expected outcome:
# - Advanced tests pass and you can explain when a block is the right abstraction.

class Notifier
  def notify_all(users)
    return [] unless block_given?

    users.map { |u| yield "Notify #{u}" }
  end
end

# ANSWER KEY (BASIC)
# Topic: topic_02_methods_keywords_blocks
#
# Solution idea:
# - Use keyword arguments so the call site explains the meaning of each wrapper.
# - Keep defaults in the method signature instead of branching inside the method body.

class Formatter
  def wrap(text, left: "[", right: "]")
    "#{left}#{text}#{right}"
  end
end

# ANSWER KEY (ADVANCED)
# Topic: topic_02_methods_keywords_blocks
#
# Solution idea:
# - The notifier owns the iteration over users.
# - The caller owns what to do with each generated message.
# - Returning an empty array when no block is given keeps the method safe for the exercise.

class Notifier
  def notify_all(users)
    return [] unless block_given?

    users.map { |user| yield "Notify #{user}" }
  end
end

# This spec is your learning companion for topic_02_methods_keywords_blocks.
#
# 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_02_methods_keywords_blocks" do
  describe "EXAMPLE purpose: understand the reference implementation" do
      it "greets with default and custom punctuation" do
        g = Greeter.new
        expect(g.greet("Mina")).to eq("Hello, Mina!")
        expect(g.greet("Mina", punctuation: ".")).to eq("Hello, Mina.")
      end
  end

  describe "BASIC EXERCISE purpose: implement the comparable task" do
      it "wraps text with keyword defaults" do
        f = Formatter.new
        expect(f.wrap("ruby")).to eq("[ruby]")
        expect(f.wrap("ruby", left: "<", right: ">")) .to eq("<ruby>")
      end
  end

  describe "ADVANCED EXERCISE purpose: solve challenge and edge cases" do
      it "yields notifications and handles empty list" do
        n = Notifier.new
        out = n.notify_all(%w[a b]) { |msg| msg.upcase }
        expect(out).to eq(["NOTIFY A", "NOTIFY B"])
        expect(n.notify_all([]) { |msg| msg }).to eq([])
      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}")"