```html

Patrones de Diseño en Ruby: Implementando el Patrón Chain of Responsibility

Los patrones de diseño son soluciones probadas a problemas comunes que surgen en el desarrollo de software. Uno de estos patrones es el Chain of Responsibility, que permite el envío de una solicitud a través de una cadena de objetos receptores hasta que uno de ellos la maneje. Este patrón es especialmente útil en situaciones donde se desea desacoplar el emisor de la solicitud del receptor.

¿Qué es el Patrón Chain of Responsibility?

El patrón Chain of Responsibility es un patrón de comportamiento que permite que múltiples objetos manejen una solicitud sin que el emisor de la solicitud necesite conocer cuál objeto la manejará. Esto se logra encadenando los objetos receptores y permitiendo que cada uno decida si puede manejar la solicitud o pasarla al siguiente en la cadena.

Ventajas del Patrón Chain of Responsibility

Desacoplamiento: El emisor no necesita conocer la lógica de manejo de la solicitud.
Flexibilidad: Se pueden agregar o quitar manejadores de manera dinámica.
Responsabilidad: Permite que varios objetos manejen la solicitud, promoviendo la responsabilidad compartida.

Desventajas del Patrón Chain of Responsibility

Rendimiento: Puede haber una sobrecarga de rendimiento si la cadena es demasiado larga.
Complejidad: La lógica de la cadena puede volverse complicada si no se gestiona adecuadamente.

Implementación del Patrón Chain of Responsibility en Ruby

A continuación, veremos cómo implementar este patrón en Ruby. Para ello, crearemos una cadena de manejadores que procesará diferentes tipos de solicitudes. Imaginemos que estamos desarrollando un sistema de soporte técnico donde diferentes niveles de soporte manejan diferentes tipos de problemas.

Definiendo la Interfaz del Manejador

Primero, definimos una clase abstracta que representará el manejador. Esta clase tendrá un método para establecer el siguiente manejador en la cadena y otro para procesar la solicitud.

class SupportHandler
  attr_accessor :next_handler

  def initialize(next_handler = nil)
    @next_handler = next_handler
  end

  def handle_request(request)
    if can_handle?(request)
      process_request(request)
    elsif @next_handler
      @next_handler.handle_request(request)
    else
      puts "Nadie puede manejar la solicitud: #{request}"
    end
  end

  def can_handle?(request)
    raise NotImplementedError, "Este método debe implementarse en la subclase"
  end

  def process_request(request)
    raise NotImplementedError, "Este método debe implementarse en la subclase"
  end
end

Creando Manejadores Concretos

A continuación, creamos varias clases que heredan de SupportHandler y que implementan la lógica para manejar solicitudes específicas.

class LevelOneSupport < SupportHandler
  def can_handle?(request)
    request == "Problema menor"
  end

  def process_request(request)
    puts "Nivel 1: Manejo de #{request}"
  end
end

class LevelTwoSupport < SupportHandler
  def can_handle?(request)
    request == "Problema moderado"
  end

  def process_request(request)
    puts "Nivel 2: Manejo de #{request}"
  end
end

class LevelThreeSupport < SupportHandler
  def can_handle?(request)
    request == "Problema grave"
  end

  def process_request(request)
    puts "Nivel 3: Manejo de #{request}"
  end
end

Configurando la Cadena de Manejadores

Ahora que tenemos nuestros manejadores, necesitamos configurar la cadena de responsabilidad. Esto se hace creando instancias de los manejadores y conectándolos entre sí.

level_one = LevelOneSupport.new
level_two = LevelTwoSupport.new(level_one)
level_three = LevelThreeSupport.new(level_two)

Probando la Cadena de Responsabilidad

Finalmente, vamos a probar nuestra implementación enviando diferentes tipos de solicitudes a la cadena de manejadores.

requests = ["Problema menor", "Problema moderado", "Problema grave", "Problema desconocido"]

requests.each do |request|
  puts "Enviando solicitud: #{request}"
  level_three.handle_request(request)
  puts "-" * 30
end

Ejemplo Completo

Para facilitar la comprensión, aquí está el código completo que hemos discutido hasta ahora:

class SupportHandler
  attr_accessor :next_handler

  def initialize(next_handler = nil)
    @next_handler = next_handler
  end

  def handle_request(request)
    if can_handle?(request)
      process_request(request)
    elsif @next_handler
      @next_handler.handle_request(request)
    else
      puts "Nadie puede manejar la solicitud: #{request}"
    end
  end

  def can_handle?(request)
    raise NotImplementedError, "Este método debe implementarse en la subclase"
  end

  def process_request(request)
    raise NotImplementedError, "Este método debe implementarse en la subclase"
  end
end

class LevelOneSupport < SupportHandler
  def can_handle?(request)
    request == "Problema menor"
  end

  def process_request(request)
    puts "Nivel 1: Manejo de #{request}"
  end
end

class LevelTwoSupport < SupportHandler
  def can_handle?(request)
    request == "Problema moderado"
  end

  def process_request(request)
    puts "Nivel 2: Manejo de #{request}"
  end
end

class LevelThreeSupport < SupportHandler
  def can_handle?(request)
    request == "Problema grave"
  end

  def process_request(request)
    puts "Nivel 3: Manejo de #{request}"
  end
end

level_one = LevelOneSupport.new
level_two = LevelTwoSupport.new(level_one)
level_three = LevelThreeSupport.new(level_two)

requests = ["Problema menor", "Problema moderado", "Problema grave", "Problema desconocido"]

requests.each do |request|
  puts "Enviando solicitud: #{request}"
  level_three.handle_request(request)
  puts "-" * 30
end

Conclusión

El patrón Chain of Responsibility es una herramienta poderosa que permite manejar solicitudes de manera flexible y desacoplada. Al implementar este patrón en Ruby, hemos creado un sistema que puede adaptarse a diferentes tipos de problemas de soporte técnico, permitiendo que cada nivel de soporte maneje lo que le corresponde. Este enfoque no solo mejora la organización del código, sino que también facilita la escalabilidad y el mantenimiento del sistema.

Al considerar el uso de patrones de diseño en tus proyectos, es importante evaluar las necesidades específicas y cómo cada patrón puede ayudar a resolver problemas de diseño. El patrón Chain of Responsibility es solo uno de los muchos patrones disponibles, pero su capacidad para crear sistemas flexibles y desacoplados lo convierte en una opción valiosa para muchos desarrolladores.

```