```html

Patrones de Diseño en Ruby: Implementando el Patrón Facade

Los patrones de diseño son soluciones probadas a problemas comunes en el desarrollo de software. En este artículo, exploraremos el patrón Facade, que es una forma de simplificar la interacción con un sistema complejo. Usaremos Ruby como nuestro lenguaje de implementación para ilustrar cómo se puede aplicar este patrón de manera efectiva.

¿Qué es el Patrón Facade?

El patrón Facade proporciona una interfaz simplificada a un conjunto de interfaces más complejas en un subsistema. Su objetivo principal es ocultar la complejidad del sistema y facilitar su uso. Esto es especialmente útil cuando un sistema tiene múltiples componentes que interactúan entre sí, ya que permite a los desarrolladores interactuar con el sistema a través de una única interfaz.

Beneficios del Patrón Facade

Reducción de la complejidad: Proporciona una interfaz más sencilla para interactuar con sistemas complejos.
Desacoplamiento: Permite que los componentes del sistema estén menos acoplados, lo que facilita el mantenimiento y las pruebas.
Mejor legibilidad: Hace que el código sea más fácil de entender al reducir la cantidad de interacciones necesarias.
Facilidad de uso: Proporciona una forma más accesible para que los nuevos desarrolladores comprendan y utilicen el sistema.

Ejemplo de Implementación del Patrón Facade en Ruby

Para ilustrar cómo implementar el patrón Facade en Ruby, consideremos un sistema de gestión de cine. Este sistema incluye varias clases que manejan películas, proyecciones y boletos. Sin embargo, interactuar con estas clases directamente puede ser complicado. Vamos a crear una fachada que simplifique esta interacción.

Definiendo las Clases del Sistema

Primero, definamos las clases que componen nuestro sistema de gestión de cine:

class Pelicula
  attr_accessor :titulo, :duracion

  def initialize(titulo, duracion)
    @titulo = titulo
    @duracion = duracion
  end

  def mostrar_detalles
    "Título: #{@titulo}, Duración: #{@duracion} minutos"
  end
end

class Proyeccion
  attr_accessor :pelicula, :hora

  def initialize(pelicula, hora)
    @pelicula = pelicula
    @hora = hora
  end

  def mostrar_proyeccion
    "Proyección de '#{@pelicula.titulo}' a las #{@hora}"
  end
end

class Boleto
  attr_accessor :proyeccion, :asiento

  def initialize(proyeccion, asiento)
    @proyeccion = proyeccion
    @asiento = asiento
  end

  def mostrar_boleto
    "Boleto para '#{@proyeccion.pelicula.titulo}' en asiento #{@asiento}"
  end
end

Creando la Clase Facade

Ahora que tenemos nuestras clases definidas, es momento de crear la fachada. La clase Facade proporcionará métodos para interactuar con el sistema sin necesidad de lidiar con la complejidad de las clases individuales.

class CineFacade
  def initialize
    @peliculas = []
    @proyecciones = []
  end

  def agregar_pelicula(titulo, duracion)
    pelicula = Pelicula.new(titulo, duracion)
    @peliculas << pelicula
    pelicula
  end

  def programar_proyeccion(titulo, hora)
    pelicula = @peliculas.find { |p| p.titulo == titulo }
    return "Película no encontrada" unless pelicula

    proyeccion = Proyeccion.new(pelicula, hora)
    @proyecciones << proyeccion
    proyeccion
  end

  def comprar_boleto(titulo, hora, asiento)
    proyeccion = @proyecciones.find { |p| p.pelicula.titulo == titulo && p.hora == hora }
    return "Proyección no encontrada" unless proyeccion

    boleto = Boleto.new(proyeccion, asiento)
    boleto
  end

  def mostrar_proyecciones
    @proyecciones.map(&:mostrar_proyeccion).join("\n")
  end
end

Uso de la Clase Facade

Veamos cómo utilizar la clase Facade para interactuar con nuestro sistema de cine de manera sencilla.

cine = CineFacade.new

# Agregar películas
cine.agregar_pelicula("Inception", 148)
cine.agregar_pelicula("Titanic", 195)

# Programar proyecciones
cine.programar_proyeccion("Inception", "18:00")
cine.programar_proyeccion("Titanic", "21:00")

# Comprar boletos
boleto1 = cine.comprar_boleto("Inception", "18:00", "A1")
boleto2 = cine.comprar_boleto("Titanic", "21:00", "B2")

# Mostrar proyecciones
puts cine.mostrar_proyecciones

# Mostrar detalles de los boletos
puts boleto1.mostrar_boleto
puts boleto2.mostrar_boleto

Conclusiones

El patrón Facade es una herramienta poderosa para simplificar la interacción con sistemas complejos. En nuestro ejemplo, hemos visto cómo encapsular la lógica de varias clases en una única interfaz, lo que facilita su uso y mejora la legibilidad del código. Este patrón no solo ayuda a reducir la complejidad, sino que también promueve un diseño más limpio y mantenible.

Al implementar el patrón Facade en Ruby, podemos crear aplicaciones más accesibles y fáciles de entender. Si bien este ejemplo se centró en un sistema de cine, el patrón Facade se puede aplicar en una variedad de contextos y sistemas, desde aplicaciones web hasta sistemas de gestión empresarial.

Al considerar el uso de patrones de diseño en tu próximo proyecto, recuerda que la simplicidad y la claridad son fundamentales. El patrón Facade puede ser el primer paso hacia un diseño más eficiente y efectivo.

```