Recursion และ Closures ผ่านปัญหา traversal ขนาดเล็ก

matcher = TitleMatchers.containing("ruby")
matcher.call("Ruby Blocks")
# => true

def sum(node)
  return node if node.is_a?(Integer)

  node.sum { |child| sum(child) }
end

def collect(node, paths = [], prefix = [])
  current = prefix + [node[:title]]
  paths << current.join(" > ") if node[:children].empty?
  node[:children].each { |child| collect(child, paths, current) }
  paths
end

def self.containing(term)
  ->(title) { title.downcase.include?(term.downcase) }
end

# EXAMPLE CODE
# Topic: topic_13_recursion_closures
#
# Purpose:
# - This file demonstrates recursion over a nested array/integer structure.
# - It should pass tests from the beginning.
# - Read it before solving the tree traversal and closure exercises.

class NestedNumberSummer
  def sum(node)
    return node if node.is_a?(Integer)

    node.sum { |child| sum(child) }
  end
end

# STUDENT TASK (BASIC)
# Topic: topic_13_recursion_closures
#
# What to do:
# - Traverse a nested category tree recursively.
# - Return the full leaf paths instead of printing directly.
# - Keep the current path explicit so the recursion is easy to follow.
#
# Expected outcome:
# - You can solve a small tree problem with a clear base case and recursive case.

class CategoryPaths
  def paths(tree, prefix = [])
    current_path = prefix + [tree[:title]]
    return [current_path.join(" > ")] if tree[:children].empty?

    tree[:children].flat_map { |child| paths(child, current_path) }
  end
end

# STUDENT TASK (ADVANCED)
# Topic: topic_13_recursion_closures
#
# Academic purpose:
# - Combine recursive traversal with a closure that captures query behavior.
# - Show that recursion can stay generic while the matching rule remains flexible.
#
# Real-world use case:
# - Content trees, nested menus, and documentation sidebars often need searches such as
#   "find all titles containing this term."
# - A matcher closure lets the search term live outside the traversal logic.
#
# Why Ruby is beautiful here:
# - Lambdas make small captured behaviors easy to create.
# - The traversal stays focused on the tree shape.
# - The matching rule can change without rewriting the recursion.
#
# What to do:
# - Build one closure factory that remembers a search term.
# - Build one recursive query object that uses the closure to decide what to collect.
# - Return matching node titles as ordinary arrays.
#
# Expected outcome:
# - Advanced tests pass and you can explain what the closure captures.

module TitleMatchers
  def self.containing(term)
    ->(title) { title.downcase.include?(term.downcase) }
  end
end

class TreeQuery
  def initialize(matcher:)
    @matcher = matcher
  end

  def matching_titles(tree)
    results = []
    visit(tree, results)
    results
  end

  private

  def visit(node, results)
    results << node[:title] if @matcher.call(node[:title])
    node[:children].each { |child| visit(child, results) }
  end
end

# ANSWER KEY (BASIC)
# Topic: topic_13_recursion_closures
#
# Solution idea:
# - Build the current path before descending.
# - If the node has no children, the recursion stops and returns one completed path.
# - Otherwise, recurse into each child and flatten the collected paths.

class CategoryPaths
  def paths(tree, prefix = [])
    current_path = prefix + [tree[:title]]
    return [current_path.join(" > ")] if tree[:children].empty?

    tree[:children].flat_map { |child| paths(child, current_path) }
  end
end

# ANSWER KEY (ADVANCED)
# Topic: topic_13_recursion_closures
#
# Solution idea:
# - The closure remembers the `term` value from where it was created.
# - `TreeQuery` only knows how to walk the tree.
# - The matcher decides which titles are worth collecting.

module TitleMatchers
  def self.containing(term)
    ->(title) { title.downcase.include?(term.downcase) }
  end
end

class TreeQuery
  def initialize(matcher:)
    @matcher = matcher
  end

  def matching_titles(tree)
    results = []
    visit(tree, results)
    results
  end

  private

  def visit(node, results)
    results << node[:title] if @matcher.call(node[:title])
    node[:children].each { |child| visit(child, results) }
  end
end

# This spec is your learning companion for topic_13_recursion_closures.
#
# How to use this file:
# 1) Run tests and observe failures or successes.
# 2) Keep the EXAMPLE specs green from the beginning.
# 3) Implement the BASIC exercise as sprint 2: recursive path collection.
# 4) Implement the ADVANCED exercise as sprint 3 and 4: closure factory plus recursive query.
#
# Expected final result:
# - All examples in this file pass.
# - You understand both recursion and closure capture in a practical setting.

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

RSpec.describe "topic_13_recursion_closures" do
  describe "EXAMPLE purpose: understand recursion through a repeated data shape" do
    it "sums nested integers recursively" do
      summer = NestedNumberSummer.new

      expect(summer.sum([1, [2, 3], [4, [5]]])).to eq(15)
      expect(summer.sum([7, [1, [2]]])).to eq(10)
    end
  end

  describe "BASIC EXERCISE purpose: traverse a tree recursively as a small sprint" do
    it "returns leaf paths from a nested category tree" do
      tree = {
        title: "Docs",
        children: [
          {
            title: "Ruby",
            children: [
              { title: "Blocks", children: [] },
              { title: "Enumerable", children: [] }
            ]
          },
          {
            title: "SQL",
            children: [
              { title: "SQLite", children: [] }
            ]
          }
        ]
      }

      paths = CategoryPaths.new.paths(tree)

      expect(paths).to eq(
        [
          "Docs > Ruby > Blocks",
          "Docs > Ruby > Enumerable",
          "Docs > SQL > SQLite"
        ]
      )
    end
  end

  describe "ADVANCED EXERCISE purpose: combine closure capture with recursive traversal" do
    it "uses a matcher closure to collect matching titles" do
      tree = {
        title: "Docs",
        children: [
          {
            title: "Ruby Basics",
            children: [
              { title: "Ruby Blocks", children: [] },
              { title: "Enumerable", children: [] }
            ]
          },
          {
            title: "SQL",
            children: [
              { title: "SQLite with Ruby", children: [] }
            ]
          }
        ]
      }

      matcher = TitleMatchers.containing("ruby")
      query = TreeQuery.new(matcher: matcher)

      expect(query.matching_titles(tree)).to eq(
        ["Ruby Basics", "Ruby Blocks", "SQLite with Ruby"]
      )
    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}")"