Skip to content

Commit be478f7

Browse files
T-FangT-Fang
authored
Merge pull request nus-cs2103-AY2021S1#85 from lll-jy/scoping
Refine scoping of existing commands.
2 parents 3967524 + 89ef446 commit be478f7

File tree

3 files changed

+141
-41
lines changed

3 files changed

+141
-41
lines changed

‎src/main/java/seedu/address/logic/LogicManager.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ public CommandResult execute(String commandText) throws CommandException, ParseE
4343
logger.info("----------------[USER COMMAND][" + commandText + "]");
4444

4545
CommandResult commandResult;
46-
Command command = mainCatalogueParser.parseCommand(commandText);
46+
Command command = mainCatalogueParser.parseCommand(commandText, model.getStatus());
4747
commandResult = command.execute(model);
4848

4949
try {

‎src/main/java/seedu/address/logic/parser/MainCatalogueParser.java

Lines changed: 54 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@
1818
import seedu.address.logic.commands.ListCommand;
1919
import seedu.address.logic.commands.StartCommand;
2020
import seedu.address.logic.parser.exceptions.ParseException;
21+
import seedu.address.model.exceptions.InvalidScopeException;
22+
import seedu.address.model.project.Status;
2123

2224
/**
2325
* Parses user input.
@@ -33,50 +35,79 @@ public class MainCatalogueParser {
3335
* Parses user input into command for execution.
3436
*
3537
* @param userInput full user input string
38+
* @param status the status of the current scoping
3639
* @return the command based on the user input
3740
* @throws ParseException if the user input does not conform the expected format
3841
*/
39-
public Command parseCommand(String userInput) throws ParseException {
42+
public Command parseCommand(String userInput, Status status) throws ParseException {
4043
final Matcher matcher = BASIC_COMMAND_FORMAT.matcher(userInput.trim());
4144
if (!matcher.matches()) {
4245
throw new ParseException(String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE));
4346
}
4447

4548
final String commandWord = matcher.group("commandWord");
4649
final String arguments = matcher.group("arguments");
47-
switch (commandWord) {
50+
if (status == Status.CATALOGUE) {
51+
switch (commandWord) {
4852

49-
case AddCommand.COMMAND_WORD:
50-
return new AddCommandParser().parse(arguments);
53+
case AddCommand.COMMAND_WORD:
54+
return new AddCommandParser().parse(arguments);
5155

52-
case EditCommand.COMMAND_WORD:
53-
return new EditCommandParser().parse(arguments);
56+
case EditCommand.COMMAND_WORD:
57+
return new EditCommandParser().parse(arguments);
5458

55-
case DeleteCommand.COMMAND_WORD:
56-
return new DeleteCommandParser().parse(arguments);
59+
case DeleteCommand.COMMAND_WORD:
60+
return new DeleteCommandParser().parse(arguments);
5761

58-
case ClearCommand.COMMAND_WORD:
59-
return new ClearCommand();
62+
case ClearCommand.COMMAND_WORD:
63+
return new ClearCommand();
6064

61-
case FindCommand.COMMAND_WORD:
62-
return new FindCommandParser().parse(arguments);
65+
case FindCommand.COMMAND_WORD:
66+
return new FindCommandParser().parse(arguments);
6367

64-
case ListCommand.COMMAND_WORD:
65-
return new ListCommand();
68+
case ListCommand.COMMAND_WORD:
69+
return new ListCommand();
6670

67-
case ExitCommand.COMMAND_WORD:
68-
return new ExitCommand();
71+
case ExitCommand.COMMAND_WORD:
72+
return new ExitCommand();
6973

70-
case HelpCommand.COMMAND_WORD:
71-
return new HelpCommand();
74+
case HelpCommand.COMMAND_WORD:
75+
return new HelpCommand();
7276

73-
case StartCommand.COMMAND_WORD:
74-
return new StartCommandParser().parse(arguments);
77+
case StartCommand.COMMAND_WORD:
78+
return new StartCommandParser().parse(arguments);
7579

76-
case LeaveCommand.COMMAND_WORD:
77-
return new LeaveCommand();
80+
case LeaveCommand.COMMAND_WORD:
81+
throw new InvalidScopeException(Status.PROJECT, Status.CATALOGUE);
7882

79-
default:
83+
default:
84+
throw new ParseException(MESSAGE_UNKNOWN_COMMAND);
85+
}
86+
} else if (status == Status.PROJECT) {
87+
switch (commandWord) {
88+
89+
case LeaveCommand.COMMAND_WORD:
90+
return new LeaveCommand();
91+
92+
case ExitCommand.COMMAND_WORD:
93+
return new ExitCommand();
94+
95+
case HelpCommand.COMMAND_WORD:
96+
return new HelpCommand();
97+
98+
case AddCommand.COMMAND_WORD:
99+
case EditCommand.COMMAND_WORD:
100+
case DeleteCommand.COMMAND_WORD:
101+
case ClearCommand.COMMAND_WORD:
102+
case FindCommand.COMMAND_WORD:
103+
case ListCommand.COMMAND_WORD:
104+
case StartCommand.COMMAND_WORD:
105+
throw new InvalidScopeException(Status.CATALOGUE, Status.PROJECT);
106+
107+
default:
108+
throw new ParseException(MESSAGE_UNKNOWN_COMMAND);
109+
}
110+
} else {
80111
throw new ParseException(MESSAGE_UNKNOWN_COMMAND);
81112
}
82113
}

‎src/test/java/seedu/address/logic/parser/MainCatalogueParserTest.java

Lines changed: 86 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -25,8 +25,10 @@
2525
import seedu.address.logic.commands.ListCommand;
2626
import seedu.address.logic.commands.StartCommand;
2727
import seedu.address.logic.parser.exceptions.ParseException;
28+
import seedu.address.model.exceptions.InvalidScopeException;
2829
import seedu.address.model.project.NameContainsKeywordsPredicate;
2930
import seedu.address.model.project.Project;
31+
import seedu.address.model.project.Status;
3032
import seedu.address.testutil.EditProjectDescriptorBuilder;
3133
import seedu.address.testutil.ProjectBuilder;
3234
import seedu.address.testutil.ProjectUtil;
@@ -38,20 +40,20 @@ public class MainCatalogueParserTest {
3840
@Test
3941
public void parseCommand_add() throws Exception {
4042
Project project = new ProjectBuilder().build();
41-
AddCommand command = (AddCommand) parser.parseCommand(ProjectUtil.getAddCommand(project));
43+
AddCommand command = (AddCommand) parser.parseCommand(ProjectUtil.getAddCommand(project), Status.CATALOGUE);
4244
assertEquals(new AddCommand(project), command);
4345
}
4446

4547
@Test
4648
public void parseCommand_clear() throws Exception {
47-
assertTrue(parser.parseCommand(ClearCommand.COMMAND_WORD) instanceof ClearCommand);
48-
assertTrue(parser.parseCommand(ClearCommand.COMMAND_WORD + " 3") instanceof ClearCommand);
49+
assertTrue(parser.parseCommand(ClearCommand.COMMAND_WORD, Status.CATALOGUE) instanceof ClearCommand);
50+
assertTrue(parser.parseCommand(ClearCommand.COMMAND_WORD + " 3", Status.CATALOGUE) instanceof ClearCommand);
4951
}
5052

5153
@Test
5254
public void parseCommand_delete() throws Exception {
5355
DeleteCommand command = (DeleteCommand) parser.parseCommand(
54-
DeleteCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased());
56+
DeleteCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased(), Status.CATALOGUE);
5557
assertEquals(new DeleteCommand(INDEX_FIRST_PROJECT), command);
5658
}
5759

@@ -60,57 +62,124 @@ public void parseCommand_edit() throws Exception {
6062
Project project = new ProjectBuilder().build();
6163
EditProjectDescriptor descriptor = new EditProjectDescriptorBuilder(project).build();
6264
EditCommand command = (EditCommand) parser.parseCommand(EditCommand.COMMAND_WORD + " "
63-
+ INDEX_FIRST_PROJECT.getOneBased() + " " + ProjectUtil.getEditProjectDescriptorDetails(descriptor));
65+
+ INDEX_FIRST_PROJECT.getOneBased() + " " + ProjectUtil.getEditProjectDescriptorDetails(descriptor),
66+
Status.CATALOGUE);
6467
assertEquals(new EditCommand(INDEX_FIRST_PROJECT, descriptor), command);
6568
}
6669

6770
@Test
6871
public void parseCommand_exit() throws Exception {
69-
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD) instanceof ExitCommand);
70-
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD + " 3") instanceof ExitCommand);
72+
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD, Status.CATALOGUE) instanceof ExitCommand);
73+
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD + " 3", Status.CATALOGUE) instanceof ExitCommand);
74+
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD, Status.PROJECT) instanceof ExitCommand);
75+
assertTrue(parser.parseCommand(ExitCommand.COMMAND_WORD + " 3", Status.PROJECT) instanceof ExitCommand);
7176
}
7277

7378
@Test
7479
public void parseCommand_find() throws Exception {
7580
List<String> keywords = Arrays.asList("foo", "bar", "baz");
7681
FindCommand command = (FindCommand) parser.parseCommand(
77-
FindCommand.COMMAND_WORD + " " + keywords.stream().collect(Collectors.joining(" ")));
82+
FindCommand.COMMAND_WORD + " " + keywords.stream().collect(Collectors.joining(" ")), Status.CATALOGUE);
7883
assertEquals(new FindCommand(new NameContainsKeywordsPredicate(keywords)), command);
7984
}
8085

8186
@Test
8287
public void parseCommand_help() throws Exception {
83-
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD) instanceof HelpCommand);
84-
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD + " 3") instanceof HelpCommand);
88+
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD, Status.CATALOGUE) instanceof HelpCommand);
89+
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD + " 3", Status.CATALOGUE) instanceof HelpCommand);
90+
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD, Status.PROJECT) instanceof HelpCommand);
91+
assertTrue(parser.parseCommand(HelpCommand.COMMAND_WORD + " 3", Status.PROJECT) instanceof HelpCommand);
8592
}
8693

8794
@Test
8895
public void parseCommand_list() throws Exception {
89-
assertTrue(parser.parseCommand(ListCommand.COMMAND_WORD) instanceof ListCommand);
90-
assertTrue(parser.parseCommand(ListCommand.COMMAND_WORD + " 3") instanceof ListCommand);
96+
assertTrue(parser.parseCommand(ListCommand.COMMAND_WORD, Status.CATALOGUE) instanceof ListCommand);
97+
assertTrue(parser.parseCommand(ListCommand.COMMAND_WORD + " 3", Status.CATALOGUE) instanceof ListCommand);
9198
}
9299

93100
@Test
94101
public void parseCommand_start() throws Exception {
95102
StartCommand command = (StartCommand) parser.parseCommand(
96-
StartCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased());
103+
StartCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased(), Status.CATALOGUE);
97104
assertEquals(new StartCommand(INDEX_FIRST_PROJECT), command);
98105
}
99106

100107
@Test
101108
public void parseCommand_leave() throws Exception {
102-
assertTrue(parser.parseCommand(LeaveCommand.COMMAND_WORD) instanceof LeaveCommand);
103-
assertTrue(parser.parseCommand(LeaveCommand.COMMAND_WORD + " 3") instanceof LeaveCommand);
109+
assertTrue(parser.parseCommand(LeaveCommand.COMMAND_WORD, Status.PROJECT) instanceof LeaveCommand);
110+
assertTrue(parser.parseCommand(LeaveCommand.COMMAND_WORD + " 3", Status.PROJECT) instanceof LeaveCommand);
104111
}
105112

106113
@Test
107114
public void parseCommand_unrecognisedInput_throwsParseException() {
108115
assertThrows(ParseException.class, String.format(MESSAGE_INVALID_COMMAND_FORMAT, HelpCommand.MESSAGE_USAGE), ()
109-
-> parser.parseCommand(""));
116+
-> parser.parseCommand("", Status.CATALOGUE));
110117
}
111118

112119
@Test
113120
public void parseCommand_unknownCommand_throwsParseException() {
114-
assertThrows(ParseException.class, MESSAGE_UNKNOWN_COMMAND, () -> parser.parseCommand("unknownCommand"));
121+
assertThrows(ParseException.class, MESSAGE_UNKNOWN_COMMAND, () -> parser.parseCommand("unknownCommand",
122+
Status.CATALOGUE));
123+
}
124+
125+
@Test
126+
public void parseCommand_invalidScope_throwsInvalidScopeException() {
127+
try {
128+
Project project = new ProjectBuilder().build();
129+
parser.parseCommand(ProjectUtil.getAddCommand(project), Status.PROJECT);
130+
} catch (Exception e) {
131+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
132+
}
133+
134+
try {
135+
parser.parseCommand(ClearCommand.COMMAND_WORD, Status.PROJECT);
136+
} catch (Exception e) {
137+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
138+
}
139+
140+
try {
141+
parser.parseCommand(
142+
DeleteCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased(), Status.PROJECT);
143+
} catch (Exception e) {
144+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
145+
}
146+
147+
try {
148+
Project project = new ProjectBuilder().build();
149+
EditProjectDescriptor descriptor = new EditProjectDescriptorBuilder(project).build();
150+
parser.parseCommand(EditCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased()
151+
+ " " + ProjectUtil.getEditProjectDescriptorDetails(descriptor),
152+
Status.PROJECT);
153+
} catch (Exception e) {
154+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
155+
}
156+
157+
try {
158+
List<String> keywords = Arrays.asList("foo", "bar", "baz");
159+
parser.parseCommand(
160+
FindCommand.COMMAND_WORD + " " + keywords.stream().collect(Collectors.joining(" ")),
161+
Status.CATALOGUE);
162+
} catch (Exception e) {
163+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
164+
}
165+
166+
try {
167+
parser.parseCommand(ListCommand.COMMAND_WORD, Status.PROJECT);
168+
} catch (Exception e) {
169+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
170+
}
171+
172+
try {
173+
parser.parseCommand(
174+
StartCommand.COMMAND_WORD + " " + INDEX_FIRST_PROJECT.getOneBased(), Status.PROJECT);
175+
} catch (Exception e) {
176+
assertEquals(new InvalidScopeException(Status.CATALOGUE, Status.PROJECT), e);
177+
}
178+
179+
try {
180+
parser.parseCommand(LeaveCommand.COMMAND_WORD, Status.CATALOGUE);
181+
} catch (Exception e) {
182+
assertEquals(new InvalidScopeException(Status.PROJECT, Status.CATALOGUE), e);
183+
}
115184
}
116185
}

0 commit comments

Comments
 (0)