사다리-함수형 프로그래밍

src/main/java/LadderApplication.java

@@ -0,0 +1,23 @@
+import controller.LadderController;
+import repository.ladder.LadderRepository;
+import repository.results.ResultsRepository;
+import repository.users.UserRepository;
+import service.ladder.LadderServiceImpl;
+import service.results.ResultsServiceImpl;
+import service.users.UserServiceImpl;
+import view.InputView;
+import view.OutputView;
+
+public class LadderApplication {
+    public static void main(String[] args) {
+        LadderController ladderController = new LadderController(
+                new LadderServiceImpl(new LadderRepository()),
+                new UserServiceImpl(new UserRepository()),
+                new ResultsServiceImpl(new ResultsRepository()),
+                new OutputView(),
+                new InputView()
+        );
+
+        ladderController.start();
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,82 @@
+package controller;
+
+import domain.ladder.Ladder;
+import domain.ladder.LadderLine;
+import domain.results.Results;
+import domain.users.User;
+import domain.users.Users;
+import service.ladder.LadderService;
+import service.results.ResultsService;
+import service.users.UserService;
+import view.InputView;
+import view.OutputView;
+
+public class LadderController {
+
+    private final LadderService ladderService;
+    private final UserService userService;
+    private final ResultsService resultsService;
+    private final OutputView outputView;
+    private final InputView inputView;
+
+    public LadderController(final LadderService ladderService, final UserService userService, final ResultsService resultsService, final OutputView outputView, final InputView inputView) {
+        this.ladderService = ladderService;
+        this.userService = userService;
+        this.resultsService = resultsService;
+        this.outputView = outputView;
+        this.inputView = inputView;
+    }
+
+    public void start() {
+        userService.makeUsers(inputView.inputUserNames());
+        resultsService.makeResults(inputView.inputResults());
+        ladderService.makeLadder(userService.getUsers().users().size(), inputView.inputHeight());
+
+        userService.updatePosition(ladderService.getLadder(), userService.getUsers());
+
+        printLadder(userService.getUsers(), ladderService.getLadder(), resultsService.getResults());
+        printLadderResult(userService.getUsers(), resultsService.getResults());
+    }
+
+    private void printLadder(final Users users, final Ladder ladder, final Results results) {
+        for (User user : users.users()) {
+            outputView.printUser(user.getName());
+        }
+        outputView.printEmpty();
+        for (LadderLine ladderLine : ladder.ladderLines()) {
+            outputView.printLadderLine(ladderLine.line());
+        }
+        for (String result : results.results()) {
+            outputView.printResult(result);
+        }
+        outputView.printEmpty();
+    }
+
+    private void printLadderResult(final Users users, final Results results) {
+        while (true) {
+            final String wantedUserName = inputView.inputWantedUserName();
+            final boolean isAll = checkUserName(wantedUserName);
+            printResult(wantedUserName, users, results, isAll);
+        }
+    }
+
+    private boolean checkUserName(final String wantedUserName) {
+        return wantedUserName.equals("all");
+    }
+
+    private void printResult(final String wantedUserName, final Users users, final Results results, final boolean isAll) {
+        if (!isAll) {
+            outputView.printExecutionResult();
+            outputView.printUserResult(results.results()
+                    .get(userService.findByName(wantedUserName).getPosition())
+            );
+            return;
+        }
+
+        outputView.printExecutionResult();
+        for (User user : users.users()) {
+            outputView.printAllUserResults(user.getName(), results.results()
+                    .get(user.getPosition()));
+        }
+    }
+}

src/main/java/domain/ladder/Ladder.java

@@ -0,0 +1,9 @@
+package domain.ladder;
+
+import java.util.List;
+
+public record Ladder(
+        List<LadderLine> ladderLines,
+        LadderInfo ladderInfo
+) {
+}

src/main/java/domain/ladder/LadderInfo.java

@@ -0,0 +1,7 @@
+package domain.ladder;
+
+public record LadderInfo(
+        int width,
+        int height
+) {
+}

src/main/java/domain/ladder/LadderLine.java

@@ -0,0 +1,9 @@
+package domain.ladder;
+
+import java.util.List;
+
+public record LadderLine(
+        List<Boolean> connections,
+        String line
+) {
+}

src/main/java/domain/ladder/LadderLineConnection.java

@@ -0,0 +1,28 @@
+package domain.ladder;
+
+import java.util.Arrays;
+
+public enum LadderLineConnection {
+
+    CONNECT_LADDER("|-----", true),
+    NOT_CONNECT_LADDER("|     ", false);
+
+    LadderLineConnection(final String ladderConnectionFormat, final boolean isConnected) {
+        this.ladderConnectionFormat = ladderConnectionFormat;
+        this.isConnected = isConnected;
+    }
+
+    private final String ladderConnectionFormat;
+    private final boolean isConnected;
+
+    public String getLadderConnectionFormat() {
+        return ladderConnectionFormat;
+    }
+
+    public static LadderLineConnection of(final boolean isConnected) {
+        return Arrays.stream(values())
+                .filter(ladderLineConnection -> ladderLineConnection.isConnected == isConnected)
+                .findAny()
+                .orElseThrow();
+    }
+}

src/main/java/domain/results/Results.java

@@ -0,0 +1,9 @@
+package domain.results;
+
+import java.util.List;
+
+public record Results(
+        List<String> results
+) {
+
+}

src/main/java/domain/users/User.java

@@ -0,0 +1,25 @@
+package domain.users;
+
+public class User {
+
+    private final String name;
+    private int position;
+
+    public User(final String name, final int position) {
+        this.name = name;
+        this.position = position;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+}

src/main/java/domain/users/Users.java

@@ -0,0 +1,8 @@
+package domain.users;
+
+import java.util.List;
+
+public record Users(
+        List<User> users
+) {
+}

src/main/java/repository/ladder/LadderRepository.java

@@ -0,0 +1,16 @@
+package repository.ladder;
+
+import domain.ladder.Ladder;
+
+public class LadderRepository {
+
+    private Ladder ladder;
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+
+    public void setLadder(final Ladder ladder) {
+        this.ladder = ladder;
+    }
+}

src/main/java/repository/results/ResultsRepository.java

@@ -0,0 +1,16 @@
+package repository.results;
+
+import domain.results.Results;
+
+public class ResultsRepository {
+
+    private Results results;
+
+    public Results getResults() {
+        return results;
+    }
+
+    public void setResults(final Results results) {
+        this.results = results;
+    }
+}

src/main/java/repository/users/UserRepository.java

@@ -0,0 +1,65 @@
+package repository.users;
+
+import domain.ladder.LadderInfo;
+import domain.ladder.LadderLine;
+import domain.users.User;
+import domain.users.Users;
+
+import java.util.List;
+
+public class UserRepository {
+
+    private Users users;
+
+    public Users getUsers() {
+        return users;
+    }
+
+    public void setUsers(final Users users) {
+        this.users = users;
+    }
+
+    public User findByName(final String userName) {
+        return users.users().stream()
+                .filter(user -> user.getName().equals(userName))
+                .findFirst()
+                .orElse(null); // 또는 예외를 던질 수 있습니다.
+    }
+
+    public void updatePosition(final User user, final List<LadderLine> ladderLines, final LadderInfo ladderInfo) {
+        for (LadderLine ladderLine : ladderLines) {
+            final boolean isConnectedRight = checkRightConnection(ladderLine.connections(), user.getPosition(), ladderInfo.width());
+            final boolean isConnectedLeft = checkLeftConnection(ladderLine.connections(), user.getPosition());
+            decideMoving(isConnectedLeft, isConnectedRight, user);
+        }
+    }
+
+    private boolean checkRightConnection(final List<Boolean> connections, final int position, final int width) {
+        if (position == width - 1) {
+            return false;
+        }
+        return connections.get(position);
+    }
+
+    private boolean checkLeftConnection(final List<Boolean> connections, final int position) {
+        if (position - 1 < 0) {
+            return false;
+        }
+        return connections.get(position - 1);
+    }
+
+    private void decideMoving(final boolean isConnectedLeft, final boolean isConnectedRight, final User user) {
+        if (!isConnectedLeft && !isConnectedRight) {
+            return;
+        }
+        decideMovingLeftOrRight(isConnectedLeft, user);
+    }
+
+    private void decideMovingLeftOrRight(final boolean isConnectedLeft, final User user) {
+        if (isConnectedLeft) {
+            user.setPosition(user.getPosition() - 1);
+            return;
+        }
+        user.setPosition(user.getPosition() + 1);
+    }
+}

src/main/java/service/ladder/LadderService.java

@@ -0,0 +1,10 @@
+package service.ladder;
+
+import domain.ladder.Ladder;
+
+public interface LadderService {
+
+    void makeLadder(final int width, final int height);
+
+    Ladder getLadder();
+}

src/main/java/service/ladder/LadderServiceImpl.java

@@ -0,0 +1,65 @@
+package service.ladder;
+
+import domain.ladder.Ladder;
+import domain.ladder.LadderInfo;
+import domain.ladder.LadderLine;
+import domain.ladder.LadderLineConnection;
+import repository.ladder.LadderRepository;
+
+import java.util.*;
+import java.util.stream.IntStream;
+
+public class LadderServiceImpl implements LadderService {
+
+    private final LadderRepository ladderRepository;
+    private static final String EDGE_OF_LADDER = "|";
+
+    public LadderServiceImpl(final LadderRepository ladderRepository) {
+        this.ladderRepository = ladderRepository;
+    }
+
+    @Override
+    public void makeLadder(final int width, final int height) {
+        ladderRepository.setLadder(new Ladder(makeLadderLines(height, width), new LadderInfo(width, height)));
+    }
+
+    private List<LadderLine> makeLadderLines(final int height, final int width) {
+        return IntStream.range(0, height)
+                .mapToObj(i -> makeLadderLine(width))
+                .toList();
+    }
+
+    private LadderLine makeLadderLine(final int width) {
+        List<Boolean> connections = makeConnections(width);
+        return new LadderLine(connections, makeLine(connections));
+    }
+
+    private List<Boolean> makeConnections(final int width) {
+        List<Boolean> connections = new ArrayList<Boolean>();
+        Random random = new Random();
+
+        while (connections.size() < width - 1) {
+            addConnections(connections, random.nextBoolean());
+        }
+
+        return connections;
+    }
+
+    private void addConnections(final List<Boolean> connections, final boolean isConnected) {
+        if (connections.isEmpty() || !isConnected || !connections.get(connections.size() - 1)) {
+            connections.add(isConnected);
+        }
+    }
+
+    private String makeLine(final List<Boolean> connections) {
+        final List<String> line = connections.stream()
+                .map(connection -> LadderLineConnection.of(connection).getLadderConnectionFormat())
+                .toList();
+        return String.join("", line) + EDGE_OF_LADDER;
+    }
+
+    @Override
+    public Ladder getLadder() {
+        return ladderRepository.getLadder();
+    }
+}

src/main/java/service/results/ResultsService.java

@@ -0,0 +1,11 @@
+package service.results;
+
+import domain.results.Results;
+
+import java.util.List;
+
+public interface ResultsService {
+    void makeResults(final List<String> results);
+
+    Results getResults();
+}