def change_structure():
"""Change structural rule."""
menu_file = os.path.join(_data_dir, "Menus", "Change_StructuralRule.json")
menu = Menu(file=menu_file)
Settings().print_rules()
rule = menu.open()
if rule:
Rules.change_structure(rule)
def change_single():
"""Change single rule."""
menu_file = os.path.join(_data_dir, "Menus", "Change_SingleRule.json")
rule_menu = Menu(file=menu_file)
Settings().print_rules()
rule = rule_menu.open()
if rule:
Rules.change_single(rule)
def remove_name():
"""Remove selected name from Names.json."""
names_file = os.path.join(_data_dir, "Names.json")
with open(names_file, "r") as file:
name_list = json.load(file)
options = [(name, name) for name in name_list]
menu = Menu()
menu.extend(options)
selection = menu.open()
if selection:
Names.remove(selection)
def view_runs():
"""Handle menu for viewing runs."""
def set_options(menu, file):
option_list = [option for option in os.listdir(_runs_dir)]
label_list = [label for label in option_list]
menu.options = []
menu.load(file)
menu.extend(zip(label_list, option_list))
menu_file = os.path.join(_data_dir, "Menus", "View_Runs.json")
view_menu = Menu()
view_menu.close_after_choice = True
set_options(view_menu, menu_file)
run = view_menu.open()
if run is not None:
view_run(run)
set_options(view_menu, menu_file)
def _select_explosion_child(self, option_keys):
keys = [(self.tree[str(key)], key) for key in option_keys]
menu = Menu()
menu.close_after_choice = True
menu.extend(keys)
menu.prompt = self._explosion_message(option_keys[0])
selection = menu.open()
if selection is None:
self._exit = True
return
return Key(selection)
def view_run(run):
"""Display a single run."""
run_file = os.path.join(_runs_dir, run)
with open(run_file, "r") as file:
forest = json.load(file)
forest_menu = Menu()
forest_menu.clear_after_print = False
def display(t):
return lambda: DisplayTrees.display(t)
callable_options = map(display, forest.values())
option_list = zip(forest.keys(), callable_options)
forest_menu.extend(option_list)
forest_menu.open()
def change_multiple():
"""Change multiple rules."""
rule_file = os.path.join(_data_dir, "Menus", "Change_MultipleRules.json")
rules_menu = Menu(file=rule_file)
Settings().print_rules()
group = rules_menu.open()
mode_file = os.path.join(_data_dir, "Menus", "Change_RuleMode.json")
mode_menu = Menu(file=mode_file)
mode = mode_menu.open()
if group and mode:
Rules.change_multiple(group, mode)
def change_rules():
"""Handle menu for changing rules."""
menu_file = os.path.join(_data_dir, "Menus", "Change_RulesSuperMenu.json")
rules_menu = Menu(file=menu_file)
Settings().print_rules()
rules_menu.open()
def main_menu():
"""Handle main menu."""
menu_file = os.path.join(_data_dir, "Menus", "Main.json")
main = Menu(file=menu_file)
Settings().print_rules()
main.open()
def delete_runs_confirm():
"""Confirm user wants to delete contents of Runs directory."""
menu_file = os.path.join(_data_dir, "Menus", "Confirm_DeleteRuns.json")
menu = Menu(file=menu_file)
menu.close_after_choice = True
menu.open()
def names_menu():
"""Handle menu for viewing/changing names."""
menu_file = os.path.join(_data_dir, "Menus", "View_Names.json")
menu = Menu(file=menu_file)
menu.open()
class TestMenus(unittest.TestCase):
def setUp(self):
self.menu = Menu()
self.mock_file = os.path.join(current_dir, "../mocks", "Menus",
"TestMenu.json")
def capture_menu_stdout(self, inputs: list):
"""Helper method for capturing menu outputs.
:param inputs: a list of ints representing desired menu options.
(For results, last item should be enough 0s to exit the program.)
:return: standard output sent during menu call
"""
with patch("builtins.input", side_effect=inputs):
with patch("Controllers.Menus.Base.Menu._show_options",
new=lambda *args: print("")):
with patch("sys.stdout",
new_callable=io.StringIO) as captured_out:
self.menu._separator = ""
self.menu.open()
return captured_out.getvalue().strip()
def capture_menu_return_value(self, inputs: list):
"""Helper method for capturing menu return values (and
eliminating stdout artifacts in the test window)
:param inputs: a list of ints representing desired menu options.
(For results, last item should be enough 0s to exit the program.)
:return: the return value of the selected function.
"""
with patch("builtins.input", side_effect=inputs):
with patch("Controllers.Menus.Base.Menu._show_options",
new=lambda *args: print("")):
with patch("sys.stdout", new_callable=io.StringIO):
return_value = self.menu.open()
return return_value
def test_menu_starts_with_quit_item(self):
self.assertEqual("Exit", self.menu.options[0].label)
def test_menu_options(self):
test_options = [("wow", lambda *args: print("much wow"))]
self.menu.extend(test_options)
output = self.capture_menu_stdout(inputs=[1, 0])
self.assertEqual("much wow", output)
def test_basic_lambda_from_file(self):
self.menu.load(self.mock_file)
output = self.capture_menu_return_value(inputs=[1])
self.assertEqual(14, output)
def test_import_package_using_file(self):
self.menu.load(self.mock_file)
result = self.capture_menu_return_value([2])
self.assertEqual("test", result.prop)
def test_non_callable_options_return(self):
self.menu.load(self.mock_file)
result = self.capture_menu_return_value([3])
self.assertEqual("TEST_STRING", result)
def setUp(self):
self.menu = Menu()
self.mock_file = os.path.join(current_dir, "../mocks", "Menus",
"TestMenu.json")