What you will implement in lab 5: For lab 5, you will be creating a few additional commands to increase the functionality of the program. The commands you will modify or implement are listed below, you will find further details on the specification and requirements of each command later  in this document. In lab 5, you will:

1.   Create and implement a command called “ ls” to list all of the files stored in the file system

2.   Create and implement a command called “ remove” to remove a file from the filesystem

3.   Modify the “touch” command to support creating password protected files

4.   Create and implement a command called “cat” that concatenates or writes user input into a file

5.   Create and implement a command called “ds” that displays the contents of a file based on the file’s type

6.   Create and implement a command called “copy” that makes a copy of an existing file and stores it in the file system with a different name (prototype pattern)

7.   Create and implement a command called “ rename” that renames an existing file in the file system (composite pattern, strategy pattern)

And finally, the details …

Modify, or create and implement the following commands as described below. All commands you add should be ConcreteCommand objects as part of the command pattern. You should  name your classes exactly as they are typed below when highlighted in blue. Header and     source files for your classes should already be created and linked in the solution.

Note: You should not:

●    Modify any base class interfaces to include additional functions not described in this document or studio assignments. For example: you cannot add a function to AbstractFile to return the file’s concrete type. You may modify AbstractFile to support the prototype    pattern as this is required.

● Modify any tests.

●   Determine a file’s type in a command object by using the file’s name and extension.    Command objects should not need to understand the types of files they are interacting with.

Doing any of the above will result in deductions.

1. Create and implement LSCommand in LSCommand.h/.cpp (15 points): The LSCommand will be invoked by the user by typing “ ls” into the command prompt. It should output to the terminal the names of all files currently in the file system. To support this, you should first add a function to the AbstractFileSystem interface called “getFileNames”  that takes no parameters and returns a std::set<string> containing the   names of all files in the file system. Implement this function in SimpleFileSystem. You     can assume all file names are less than 20 chars total (you can enforce this in “touch” if you would like). The output of the “ ls” command should look as below (assume we have

5 files in the file system currently: file.txt, image.img, other.txt, file2.txt, image2.img):

$ ls // the command given by the user

file.txt file2.txt // output of the command

image.img image2.img

other.txt

More specifically, 2 files should be printed per line and the file names should be evenly spaced and aligned appropriately.

The “ ls” command should also support an additional option, “-m” , which will display a  single file per line along with the metadata associated with that file as below (sizes are made up):

$ ls -m

file.txt text 15

file2.txt text 10

image.img image 4

image2.img image 9

other.txt test 0

When the command is executed, it should return 0 if the command executes successfully, or some non-zero value if the command fails for some reason.

Hint: You may already have a visitor that can help with this. Given a file name, how would you obtain a pointer to the file so that you can “visit” it?

Other Hint: When the CommandPrompt executes a command, what does it pass to the command’s execute function if the user enters “ ls”? What about “ ls -m”? Use the debugger to figure this out if you need to.

2. Create and implement RemoveCommand (RemoveCommand.h/.cpp)(5 points):

This command should remove the file with the provided name from the file system. If the file is unable to be removed for some reason, the command should return a non-zero value indicating this. Otherwise, it should return 0 if the file was removed successfully. The command should be invoked by the user with “ rm ” , such as below:

$  ls

file.txt        image.img     // file system contains these

files

$ rm file.txt // rm one of the files

$ ls

image.img // file.txt was successfully removed

$ // ready for the next command from the user

3. Modify your TouchCommand from studio 21 to support creating password protected files (10 points): Update “touch” with an option to create a file that is password protected. When touch is invoked with the “-p” option, a password protected  file should be created rather than a regular file. You must use your Proxy from studio 21 to support this. The touch command should create the file, prompt the user for a password, and then set up the proxy to protect the file. Then add the proxy to the file system. An example is below:

$ touch file.txt // creates file.txt and adds it, no password

$ touch file1.txt -p // -p comes after the filename

What is the password? // prompt the user for a password

1234 // user input: a not very safe password

$

After implementing cat and ds below, you can verify the password protection is working correctly (cat and ds will write/read the file).

4. Create and implement CatCommand (CatCommand.h/.cpp)(15 points): Add a new command to your program called cat. If you are unfamiliar with linux command line utilities, cat is a utility that is useful for concatenating files. The cat command can be      used to write to a file as well, which will be the purpose of our cat command. Cat can be invoked from the command prompt as follows:

$ cat <filename> [-a]

will be replaced with the name of a real file in the file system. The ‘ [‘ brackets around “-a” indicate “-a” is optional. So, a real invocation of the command may look like:

$ cat file.txt // or

$ cat file.txt -a

The cat command should be defined to do the following: the -a option stands for append. If the -a option is given, the current contents of the file should be displayed (the bytes      only, not the formatted output) followed by a new line. The user should then be prompted to input data to append to the file, to input “ :wq” to save and quit, or to input “ :q” to quit    without saving. The user's input should be read from cin line by line. If the line is not        “ :wq” or “ :q” , the data should be saved temporarily. Remember getline() will trim off the    newline character (‘\n’ ), make sure to reinsert a new line character between each line of  user input when saving it. If the user enters “ :q” , the cat command should return and no  data should be written to the file. If the user enters “ :wq” , the input provided up until the   user entered “ :wq” should be appended to the file. If the user invokes cat without the -a option, the functionality should be the same as        above except the current contents of the file should not be displayed to the user before   prompting for input and when the user provides “ :wq” as input, the contents of the file should be overwritten with the data supplied by the user, rather than appended to the end of the file. Some example invocations and possible output are below(note “ds” is a   command you will implement later, it displays a file):

Note: These images show the functionality from a previous semester where we         supported directories and hierarchical file storage. The output may look a bit different (root $ instead of $ only, root/file.txt instead of file.txt, etc..). Ignore those minor differences and the images show the correct functionality.

And continued on..

As with other commands, 0 should be returned if the command executes successfully, otherwise a non-zero value should be returned indicating an error occurred.

5. Create and implement DisplayCommand (DisplayCommand.h/.cpp)(10 points): Add a new command, Display. Display is invoked with “ds” . Display opens a file and displays its contents, either formatted or not (when given the “-d” option for data only). An example invocation could be:

$ ds image.img

Or..

$ ds image.img -d

// formated

// unformatted

And here is a screenshot of it in action:

If display executes successfully, 0 should be returned. Otherwise, a non-zero value should be returned indicating an error occurred.

6. Create and implement CopyCommand (CopyCommand.h/.cpp)(15 points): The   copy command will copy a file that exists in the file system and add the copy to the file system with a different name. It is invoked with the following command structure:

cp me_with_no_extension>

Where file_to_copy is replaced with a real file that exists in the file system and                 new_name_with_no_extension is replaced with the name a user would like the copy to   be called (minus the extension). The copy will be of the same type as the original file, so the file extension should match as well. When the copy is made, the correct extension     should be added to the file name given by the user. The original file, and the copy of the  file should be unique file objects. To receive credit for this command, you must            implement the prototype pattern in order to copy a file object. If any errors occur while  copying or adding the copy to the file system, a message notifying the user the                command failed should be displayed and the copy of the file should be deleted. Here is a transcript of copy in action (kind of, I have not implemented this version of the lab yet, so some output is missing but this shows the general commands to run):

$ touch file.txt   // create file.txt

$ cat file.txt    // write to it

123456

:wq

$ cp file.txt file_copy   // create a copy

$ ds file_copy.txt        // .txt added by the cp command

123456                     // ensure it is a copy

$ cat file_copy.txt

Hello

:wq

$ ds file.txt

123456          // ensure the copy is a unique file, writing to

// the copy does not change the original

If the file is copied successfully and added to the file system, executing this command should return 0 for success. Otherwise, a non-zero value should be returned.

How should a password protected file be copied? The copy should be password           protected as well. So, not only does the file need to be copied via the prototype pattern, but the proxy for the file needs to be copied as well.

Hint: You will need to change the name of the copy to its new name, however there is no setName function in the AbstractFile interface. You should not add a setter for the file      name. Instead, it may be helpful to pass a string holding the new file name to the clone   function as part of the prototype pattern.

7. Create and Implement support for MacroCommands (10 points): Macro commands  will allow us to construct commands out of other commands. Executing a macro              command simply executes each of the commands it is composed of in order. To              implement this, you should first create a class called MacroCommand (MacroCommand.h/.cpp)that inherits the AbstractCommand interface and maintains as member variables a std::vector of AbstractCommand objects (the primitive commands    the macro command will use) and a pointer to an AbstractParsingStrategy (This will be   described shortly). In our project, the macro command’s execute function takes in an      input string, however we can’t just pass that same string to each individual command the macro command is composed of, as they expect different input. The job of a                    ParsingStrategy will be to take the input provided to the macro command’s execute

function and transform it into a vector, where each string in the vector is the input that should be supplied to the corresponding individual command.                   MacroCommand’s execute function should be implemented as follows:

a.  Ask the ParsingStrategy object to parse the input provided to the macro      command’s execute function, which will return a vector. See below.

b.   For each individual command the MacroCommand is composed of, call the     individual command’s execute function with the corresponding input from the  vector returned by the ParsingStrategy. If any individual command      returns an error, return an error. Otherwise, if all individual commands execute successfully, return 0 for success.

As a MacroCommand is a composite object in the composite pattern, it needs to provide a function for adding individual commands to its vector of commands. Add a function to   its public interface called addCommand that takes a pointer to an AbstractCommand and pushes it to the end of its vector of commands. Add a function to set the macro                command’s parsing strategy as well. This should be called setParseStrategy and should take a pointer to an AbstractParsingStrategy as a parameter.

Declare the AbstractParsingStrategy (AbstractParsingStrategy.h) interface. An            AbstractParsingStrategy has a single public pure virtual member function called parse that takes a std::string parameter and returns a std::vector by value.

8. Add the rename command (5 points): To receive credit, this command must be         implemented as a MacroCommand. The rename command will change the name of an existing file (you cannot change it directly, this must be implemented as a                      MacroCommand or you will get 0 credit). Rename can be invoked by the user with “ rn” as below:

$ rn 

Where  is replaced with the name of an existing file and                           is replaced with the name the user would like the file to be called (a file extension like.txt or .img will be tacked on to the name provided by the CopyCommand). Renaming a file should do two things: First, copy the file with the copy  command giving the copy the correct new name. Second, remove the original file with     the remove command. To implement a MacroCommand with this functionality you will     need to:

●    Implement a concrete class called “ RenameParsingStrategy”                           (RenameParsingStrategy.h/.cpp) that defines the interface provided by            AbstractParsingStrategy. The interface should be defined appropriately so that given an input string like:

The parse function will return a vector containing the strings:

  // in index 0, used by the copy command

                       // in index 1, used by the remove command

●    Update main to create a MacroCommand object configured with a                      RenameParsingStrategy object as its AbstractParsingStrategy and a                  CopyCommand as well as a RemoveCommand object as its command objects. Add the MacroCommand to the CommandPrompt so it will be invoked when the user provides “ rn” as input

9. Add support for an additional MacroCommand of your choosing (5 points): Any     options supported by the individual commands should be supported by the Macro           command as well, if it makes sense to do so. Some useful command ideas I can think of are:

a.   Cat + ds - edit a file and then display it afterwards to see the edits.

b.  Touch + cat - create a file and edit it immediately

c.   Even crazier: touch + cat + ds

Update main to create a new MacroCommand object configured to support a parsing     strategy for the command you chose to implement and configure the CommandPrompt  to support your command. In your Readme, document what command you chose to implement, how the command is invoked from the command prompt, and what tests you ran to ensure it works properly. NOTE: If you need to create a new header/source file for your parsing strategy, create them along side existing header files in include/mockos/ and alongside existing .cpp files in /lib/mockos/

10. Updating main and testing (10 points): update main to configure the command prompt with each of the above commands. Test your commands thoroughly. In your lab5.md (docs/lab5.md) file, document the tests you ran as well as any errors/bugs you encountered while working. Also, at the top of your Readme.md for lab 5 (docs/lab5.md), list each group member’s name and describe how the work was split between the group members.

a. Note: Make sure to avoid memory leaks, double deletions, etc.