omrisarig13 / vocabularyteacher Goto Github PK

Add an option to load a file into an existing dictionary.

This option should take a file that contains a list of words and add them to the current dictionary in the project. This format of the file should be something that is easy to parse in python, a YAML file for example.

This should be done in a new action in the menu. This action should load the file from the disk, move over all the words inside the file and add every one of them to the dictionary. The user should be asked (and notified) about every word that is added to the dictionary this way. The user should be able to choose what to do with any words that are similar to other words inside the dictionary, the same as it is with adding new words to it.

Add an option to review the test after it has been taken. This option should print all the questions of the tests to the user, with the answer he has given and the correct answer to this question.

In this option, the user should be able to update the values of the words in case there are some errors in them. For example, the user should be able to add another word in the same word in case he answered such word in the test, but the test failed the user because of it. The user should also be able to add new words according to its answered words (for example, in case he answered a synonym for the word in the dictionary.

There are cases in which the same word has some different options to write it.
It can happen in two main cases:

1. The word has a different spelling. For example, the word color can be also written as colour.
2. The word has different options to write according to the context of the word. For example, the word run should be written as runs in case it is an action that a third body does (he/she/it). Since the purpose of the project is to teach vocabulary and not grammar, these words should be the same for the dictionary (even though it is better if the user would have added only the regular form of the word).

To support these cases, the implementation of the word couple should change. Instead of using a string to represent the words, it should save the words as a list, to let the user have multiple words with the exact same value.

This issue should also change the implementation of the test to accept all the words if they are part of the same list. The questions should always be asked on the first words in the list, and the user should keep them as the most common values of the word.

This option should not be used to synonym words. For their case, the user should add two different words to the dictionary. The test already handles correctly this case.

This issue should also improve the way the user is adding new words. He should be prompted with all the close words when it adds a new word, to make sure that the given word is really a new word and not just a slightly different spelling for the existing word.

Since this issue is changing the implementation of the word couple, it will mean that dictionaries that were saved with the previous implementation of the word couple will not be able to load correctly. This means that the interface will break after adding this new word.

(side note, sorry about any awkward sentences regarding the language, I do not know the proper definitions for these words since English is not my native language).

Add an option to print a summary of the current dictionary.

This summary will include information about how many words are there in every
level in the dictionary, and how many words there are in the dictionary.

Add documentation about the app in the readme file of the project.

Add a new command to the menu that will let the user update a word in the dictionary.

Update the README file to have explain what this project is.

Add a basic dictionary to the project.

The dictionary will be able to add words into it, get a definition of a word from it and translate between the languages in the project.

Finalize the menu module, after all the other modules are finished.

Create a proof of concept code for this project.

It will be written in python and used to run the project.
This will serve both as a proof of concept, but also as a valid program to run until the C implementation will be done.

As for now, after running the "add new word" command, it is impossible to edit or cancel the adding. It means that if the user has found out that he had a typo in the native word, he won't be able to abort the addition of the new word.

This issue should add an option to abort the addition of the new word while inside the command, without exiting the full menu.

Currently, when looking at the dictionary, the only option that there is to modify it (in case something in it is wrong) is to delete the whole dictionary and start a new one.

We should change the print action of the app to let the user update specific words from the dictionary. To do so, we should change the words and make every word in its own text section. Then, listens to clicks on this test section, when there is a click on the text section, the application should start a sub-menu that will let the user either update the word or delete it completely.

After this is done, we should move the command of "delete dictionary" into the print-dictionary menu, to let all the modification actions on the dictionary be in the same place.

After the user finishes a test, he moves to the "test finished" screen.
Currently, this page only contains the words "Test Ended!".

This screen should let the user see the results of the test (how man questions were asked, and how many he answered correctly). Adding this should be very easy, since this information already exists at the end of the test, all that should be done is to send this information to the test_result fragment and display it there.

Ideally, this page will also show the questions that were asked, and the answer that the user has given for every question. This is a bit more tricky to do. To do it, we should redesign the test action a bit, so it will save all the questions and the answers during the test, and move them to the result fragment at the end of the test.

Currently, if a given menu action causes an exception to raise in the code, the code crashes. This is not good because some user actions crush the system, and it is very annoying.

To fix it, we either should surround all the different actions with try and catch, or check if there is an option to make the menu handle the exceptions by itself.
The second option is nicer, but it might be impossible (in case the menu doesn't support this).

Add the module of the test to the project, making it run the wanted tests and about the word lists and updates them accordingly.

Add a new command to the menu that will let the user remove words from the dictionary.

Add a new command to the menu that will let the user translate a word using external resources.

Find programs that export this kind of functionality, and use one of them to allow the user to translate words that he doesn't know.

This command should also have an option to add the word rigth away to the dictionary, in case it is a new word.

Change the directory tree of the project to be more usable for the current implementation of the project.

Add the wanted questions to the project.
The questions are all the different option for possible questions that will be able to test the user about the different words in the translator.

This issue adds the four possible questions implementations, with their abstract module

Make the exit command automatically save the dictionary in case it is loaded from a file. In case it is not loaded from a file, ask the user to insert file name in case he wants to save the dictionary before exiting.

Currently, after adding a new word to the dictionary, the user is moved back to the main menu of the application. This can be annoying in case the user wants to add more than one word to his dictionary.

To change it, the view should have two buttons instead of one - the first one will add the word to the dictionary and return to the main menu. The second button should let the user add the current word, but stay in the same view, adding a new word to the dictionary.

In the current implementation, some weird characters make the program crash when it gets invalid characters as input from the user.

This is done because the various ask function (like the ask_str or ask_int). This should be fixed by adding try...catch around all the calls to the ask functions, and making sure that they do not crash when they run.

Add a new command that will let the user add more than one word at a time. This command should let the user add as many words as he like, one after the other, until he wants to exit the adding.

Add a new button to the application that will let the user save and update the preferences in the application.

Currently, there should be only one preference in the app - the number of questions to ask at each level in the test. Currently, it is saved statically as 5, it is better to change it and let the user choose for himself how many questions he wants per know level.

The preferences should be saved between running on the app (can be saved to a file, like the dictionary is currently saved). In the future, there might be more preferences that will be added to this menu, should it should be possible to do it.

When running the application with no words at all in the dictionary, it crushes.
This is a bug and it should be fixed.

The fix should be to make sure that the app doesn't crash. It should print a message to the user (saying that the application can not run tests without words in the dictionary).

When asking a question about words in the test, there might be a case in which the same word has more than one translation. In this case, the user has absolutely no way to know the right answer to the question.

The implementation that should be in this case is to accept both answers as the correct one, but in case the user has inserted the wrong answer, ask him to insert another word with the same translation. This will make sure that the user will learn all the language in the dictionary, but won't get errors in case his answer is correct.

This implementation works when translating from the native language to the learned one, but for some reason, it doesn't work for the other way around. It should be fixed.

Currently, the app has a logo (the one that appears in the app store). However, the actual logo of the app is still the default logo.

We should change the logo of the application to be the same logo as the logo in the app store. It should be really easy to do, all that should be done is to find where the logo is saved in the application and update the picture there.

The current application logo is the letters "V" and "T" one over the other. This is a really ugly logo, but it is the best I can do with my designing skills.

Someone who knows how to design should design a better logo to the application, and make it the official logo of the application.

I don't have any strong ideas about the logo, but before starting to work on it, it is a good idea to run the design by me.

Add an option to set the number of questions per level when running a test.

Add a new button to the application that will explain the application to the user. This view should have text explaining to the user how to use the application and what it is for.

Basically, we want to take the text from the readme, make it more user-friendly and put it in an about view inside the app.

Currently, when the user wants to add a new word to the dictionary, he is moved to the view, but he must click on the first text box to open the keyboard.

This should be changed since the user will always want to add open the keyboard in the same location. When the view is created, it should open the keyboard automatically for the user.

The same should happen once the user gets a question that needs a typed answer - the keyboard should be opened there as well.

Add linter and formatter to the code. They should run automatically every time the user is trying to commit new code.

Currently, the app-bar in the application is displaying the names of the fragment to the user (which makes no sense to him).

The app bar should be either completely remove from the application, or it should be updated. In case it is updated, it should take all the headers from the different fragments and put them in the app bar instead of as text inside the content of the fragment.