Patron État

Fait partie de la section Programmation orientée objet du Journey Ruby de Coddy. Leçon 49 sur 57.

Le patron état déplace le comportement qui dépend de l'état actuel d'un objet vers des objets d'état distincts. L'objet principal, le contexte, contient un état et lui transmet les appels ; un état répond et décide quel état vient ensuite :

class Red
  def next_state
    Green.new
  end

  def to_s
    "red"
  end
end

class Green
  def next_state
    Yellow.new
  end

  def to_s
    "green"
  end
end

class Yellow
  def next_state
    Red.new
  end

  def to_s
    "yellow"
  end
end

class TrafficLight
  def initialize
    @state = Red.new
  end

  def change
    @state = @state.next_state
    self
  end

  def to_s
    "light is #{@state}"
  end
end

light = TrafficLight.new
puts light
puts light.change
puts light.change.change

Sortie :

light is red
light is green
light is red

Sans le modèle, chaque méthode du contexte nécessite un case sur une valeur d’état, et un nouvel état signifie qu’il faut toutes les modifier. Avec des objets d’état, chaque état est une classe qui contient ses propres règles :

# sans le pattern
def can_go?
  case @status
  when :red then false
  when :green then true
  when :yellow then false
  end
end

# avec le pattern
def can_go?
  @state.can_go?
end

Les états peuvent refuser un événement qui ne leur convient pas. Ici, un brouillon ne peut pas être publié directement : il doit d’abord passer par la révision :

class Draft
  def submit
    Review.new
  end

  def publish
    raise ArgumentError, "cannot publish a draft"
  end

  def to_s
    "draft"
  end
end

class Review
  def publish
    Published.new
  end

  def to_s
    "in review"
  end
end

class Published
  def to_s
    "published"
  end
end

state = Draft.new
begin
  state.publish
rescue ArgumentError => e
  puts e.message
end
state = state.submit
state = state.publish
puts state

Sortie :

cannot publish a draft
published

Une classe de base partagée peut fournir à chaque état la réponse par défaut, par exemple en refusant chaque événement, afin que chaque état ne définisse que les événements qu’il accepte :

class State
  def submit
    raise ArgumentError, "cannot submit #{self}"
  end

  def approve
    raise ArgumentError, "cannot approve #{self}"
  end
end

class Review < State
  def approve
    Published.new
  end
end

Défi

Facile

Complétez le feu de circulation. Les états Red, Green et Yellow possèdent chacun next_state (red va vers green, green vers yellow, yellow vers red), can_go? (uniquement green) et to_s (la couleur). TrafficLight commence à l’état red, change passe à l’état suivant, et status renvoie red: stop ou green: go, en interrogeant l’état.

Le code fourni lit les commandes change ou status et affiche le statut après chaque commande.

Votre code doit être placé dans red.rb, green.rb, yellow.rb et traffic_light.rb. main.rb contient le code d’entrée/sortie fourni et ne peut pas être modifié.

Essayez vous-même

require_relative 'red'
require_relative 'green'
require_relative 'yellow'
require_relative 'traffic_light'

# Code d'entrée/sortie fourni : le garder tel quel
input = []
while (line = gets)
  input << line.chomp
end
light = TrafficLight.new
input.each do |cmd|
  light.change if cmd == "change"
  puts light.status
end