Provide an alternative structure of Factory Method examples (#3)

Decouple traits and implementations.

The aim is to demonstrate a value of the Factory Method
by decoupling interfaces and implementations.
Although, the full decoupling is going to be demonstrated in
the Abstract Factory example.

Author: fadeevab

creational/factory-method/README.md

@@ -6,10 +6,9 @@ of objects that will be created._
 
 ## Maze Game
 
-Implementing the Factory Method pattern using **static dispatch** (generics).
-
 This example reproduces one from the GoF Design Patterns book:
-https://en.wikipedia.org/wiki/Factory_method_pattern
+https://en.wikipedia.org/wiki/Factory_method_pattern, implementing
+the Factory Method pattern using generics (_static dispatch_).
 
 ### How to Run
 
@@ -32,10 +31,24 @@ Ordinary Room: #1
 
 ## Render Dialog
 
-Implementing the Factory Method via **dynamic dispatch**.
+This example shows a GUI framework can organize its types into
+independent modules:
+
+1. The `gui` module defines interfaces for all the components.
+   It has no external dependencies.
+2. The `html_gui` module provides HTML implementation of the base GUI.
+   Depends on `gui`.
+3. The `windows_gui` module provides Windows implementation of the base GUI.
+   Depends on `gui`.
+
+The app is a client application that can use several implementations
+of the GUI framework, depending on the current environment or configuration.
+However, most of the app code doesn't depend on specific types of GUI elements.
+All the client code works with GUI elements through abstract interfaces
+defined by the `gui` module.
 
-See [Factory Method Java Example](https://refactoring.guru/design-patterns/factory-method/java/example)
-as a reference.
+The [Abstract Factory example](../abstract-factory/) demonstrates even greater
+separation of Factory interface and its implementations.
 
 ### How to Run
 
@@ -46,7 +59,12 @@ cargo run --bin factory-method-render-dialog
 ### Output
 
 ```
+-- No OS detected, creating the HTML GUI --
 <button>Test Button</button>
 Click! Button says - 'Hello World!'
 Dialog - Refresh
 ```
+
+### Reference
+
+This example reproduces [Factory Method Java Example](https://refactoring.guru/design-patterns/factory-method/java/example).

creational/factory-method/maze-game/game.rs

@@ -0,0 +1,27 @@
+/// Maze room that is going to be instantiated with a factory method.
+pub trait Room {
+    fn render(&self);
+}
+
+/// Maze game has a factory method producing different rooms.
+pub trait MazeGame {
+    type RoomImpl: Room;
+
+    /// A factory method.
+    fn rooms(&self) -> Vec<Self::RoomImpl>;
+
+    fn play(&self) {
+        for room in self.rooms() {
+            room.render();
+        }
+    }
+}
+
+/// The client code initializes resources and does other preparations
+/// then it uses a factory to construct and run the game.
+pub fn run(maze_game: impl MazeGame) {
+    println!("Loading resources...");
+    println!("Starting the game...");
+
+    maze_game.play();
+}

creational/factory-method/maze-game/game/mod.rs

@@ -1,4 +1,4 @@
-use super::{MazeGame, Room};
+use super::game::{MazeGame, Room};
 
 #[derive(Clone)]
 pub struct MagicRoom {
@@ -17,11 +17,11 @@ impl Room for MagicRoom {
     }
 }
 
-pub struct MagicMazeGame {
+pub struct MagicMaze {
     rooms: Vec<MagicRoom>,
 }
 
-impl MagicMazeGame {
+impl MagicMaze {
     pub fn new() -> Self {
         Self {
             rooms: vec![
@@ -32,7 +32,7 @@ impl MagicMazeGame {
     }
 }
 
-impl MazeGame for MagicMazeGame {
+impl MazeGame for MagicMaze {
     type RoomImpl = MagicRoom;
 
     fn rooms(&self) -> Vec<Self::RoomImpl> {

creational/factory-method/maze-game/game/magic_maze.rs renamed to creational/factory-method/maze-game/magic_maze.rs

@@ -1,19 +1,20 @@
 mod game;
+mod magic_maze;
+mod ordinary_maze;
 
-/// The client code demonstrates that it does its own things
-/// (e.g. loading resources) and it can use a factory in a proper place to
-/// construct a game.
-fn run(game: impl game::MazeGame) {
-    println!("Loading resources...");
-    println!("Starting the game...");
-
-    game.play();
-}
+use magic_maze::MagicMaze;
+use ordinary_maze::OrdinaryMaze;
 
+/// The game runs with different mazes depending on the concrete factory type:
+/// it's either an ordinary maze or a magic maze.
+///
+/// For demonstration purposes, both mazes are used to construct the game.
 fn main() {
-    let game = game::MagicMazeGame::new();
-    run(game);
+    // Option 1: The game starts with an ordinary maze.
+    let ordinary_maze = OrdinaryMaze::new();
+    game::run(ordinary_maze);
 
-    let game = game::OrdinaryMazeGame::new();
-    run(game);
+    // Option 2: The game starts with a magic maze.
+    let magic_maze = MagicMaze::new();
+    game::run(magic_maze);
 }

creational/factory-method/maze-game/main.rs

@@ -1,4 +1,4 @@
-use super::{MazeGame, Room};
+use super::game::{MazeGame, Room};
 
 #[derive(Clone)]
 pub struct OrdinaryRoom {
@@ -17,19 +17,19 @@ impl Room for OrdinaryRoom {
     }
 }
 
-pub struct OrdinaryMazeGame {
+pub struct OrdinaryMaze {
     rooms: Vec<OrdinaryRoom>,
 }
 
-impl OrdinaryMazeGame {
+impl OrdinaryMaze {
     pub fn new() -> Self {
         Self {
             rooms: vec![OrdinaryRoom::new(1), OrdinaryRoom::new(2)],
         }
     }
 }
 
-impl MazeGame for OrdinaryMazeGame {
+impl MazeGame for OrdinaryMaze {
     type RoomImpl = OrdinaryRoom;
 
     fn rooms(&self) -> Vec<Self::RoomImpl> {

creational/factory-method/maze-game/game/ordinary_maze.rs renamed to creational/factory-method/maze-game/ordinary_maze.rs

@@ -1,12 +1,13 @@
-pub mod html;
-pub mod windows;
-
-use crate::button::Button;
+pub trait Button {
+    fn render(&self);
+    fn on_click(&self);
+}
 
 /// Dialog has a factory method `create_button`.
 ///
 /// It creates different buttons depending on a factory implementation.
 pub trait Dialog {
+    /// The factory method. It must be overridden with a concrete implementation.
     fn create_button(&self) -> Box<dyn Button>;
 
     fn render(&self) {