Simplified a lot of functionality

* Removed hardcoded command values from `match` when processing command line arguments
* Removed repair functionality and replaced it with warnings and messages
* Fixed a bug that raised an error when a user would try to remove an item using a string

README.md

@@ -29,6 +29,8 @@ rodo is a todo-list program for the command line.
     - [Uninstalling rodo locally](#uninstalling-rodo-locally)
         - [To uninstall rodo locally](#to-uninstall-rodo-locally)
 - [Using rodo](#using-rodo)
+    - [Initializing rodo](#initializing-rodo)
+        - [To initialize rodo](#to-intialize-rodo)
     - [Showing the help message](#showing-the-help-message)
         - [To show the help message](#to-show-the-help-message)
     - [Displaying your list](#displaying-your-list)
@@ -197,6 +199,15 @@ This section will teach you how to use rodo's commands.
 
 This section assumes you have [installed rodo](#installing-rodo).
 
+## Initializing rodo
+
+Before using rodo, you will need to initialize it. This means rodo will create a `~/.rodo`.
+
+### To initialize rodo
+
+1. Run `rodo init`
+2. Choose `y`
+
 ## Showing the help message
 
 The help message will provide a list of available commands. This is list useful in case you forget

src/rodo.rkt

@@ -6,164 +6,176 @@
          racket/string)
 
 ;; ------------------------------------------------
-;; values
+;; Constants
 ;; ------------------------------------------------
-(define help-command        "help")
+(define help-command-1      "help")
+(define help-command-2      "--help")
+(define help-command-3      "-h")
+(define init-command        "init")
 (define ls-command          "ls")
 (define rm-command          "rm")
 (define add-command         "add")
 (define program-name        "rodo")
-(define program-name-dotted (string-append "." program-name))
-(define home-directory-path (find-system-path 'home-dir))
-(define program-path        (build-path home-directory-path program-name-dotted))
-(define correct-permissions 384) ;; -rw------- permissions
-(define message-prefix      "> ")
+(define program-file        (string-append "." program-name))
+(define program-path        (build-path (find-system-path 'home-dir) program-file))
+(define program-permissions 384) ;; 600/-rw------- permissions
+(define newline             "\n") ;; This is easier to see than a '\n' inside of a string
+(define double-newline      "\n\n")
 
 ;; ------------------------------------------------
-;; messages
+;; Messages
 ;; ------------------------------------------------
 (define messages
   (hash
-   'error-add                (list (format "Error: No arguments were found after the '~a' command." add-command)
-                                   (format "Suggestion: Try using a quoted argument after the '~a' command." ls-command)
-                                   (format "Example: ~a add \"Go for a walk\"" program-name))
+    'error-too-many-arguments
+    (format (string-append "Error: Too many arguments." newline
+                           "Try running '~a ~a' for more information.")
+            program-name
+            help-command-1)
 
-   'item-not-found           (list         "Error: Item not found."
-                                   (format "Suggestion: Try using the '~a' command to see which number " ls-command)
-                                           "            correlates to which message in your list."
-                                   (format "Example: ~a ~a" program-name ls-command))
+    'error-incorrect-usage
+    (format (string-append "Error: Incorrect usage." newline
+                           "Try running '~a ~a' for more information.")
+            program-name
+            help-command-1)
 
-   'error-rm                 (list (format "Error: No arguments were found after the '~a' command." rm-command)
-                                   (format "Suggestion: Try using a number after the '~a' command." rm-command)
-                                   (format "Example: ~a ~a 2" program-name rm-command)
-                                   ""
-                                   (format "Note: You may need to run the '~a' command to see which " ls-command)
-                                           "      number correlates to which item in your list."
-                                   (format "Example: ~a ~a" program-name ls-command))
+    'error-file-already-exists
+    (format "Error: The file '~a' already exists." program-path)
 
-   'error-usage              (list         "Error: Incorrect usage."
-                                   (format "Suggestions: Try running the '~a' command." help-command)
-                                   (format "Example: ~a ~a" program-name help-command))
+    'error-fake-file-exists
+    (format (string-append "Error: The directory '~a' exists." newline
+                           "Try moving, renaming, or deleting this directory.")
+            program-path)
 
-   'error-ls                 (list (format "Error: Found arguments after the '~a' command." ls-command)
-                                   (format "Suggestions: Try using '~a' without any arguments." ls-command)
-                                   (format "Example: ~a ~a" program-name ls-command))
+    'error-file-doesnt-exist
+    (format (string-append "Error: '~a' doesn't exist." newline
+                           "Try running '~a ~a'.")
+            program-path
+            program-name
+            init-command)
 
-   'error-fake-file          (list (format "Error: A '~a' directory was found in your home directory." program-name-dotted)
-                                   (format "Suggestion 1: Move the '~a' directory out of your " program-name-dotted)
-                                   (format "              home directory before using ~a." program-name)
-                                   (format "Suggestion 2: Rename the '~a' directory before using ~a." program-name-dotted program-name))
+    'error-item-not-found
+    "Error: Item not found."
 
-   'error-permissions-prompt (list (format "Error: '~a''s permissions are incorrect." program-path)
-                                           "Would you like to fix them? [y/n]")
 
-   'cancel-creation          (list (format "Cancelled the creation of ~a." program-path))
+    'warning-permissions
+    (format (string-append "Warning: The permissions on your '~a' file are incorrect." newline
+                           "Other users on this host may be able to read your file." newline
+                           "Try running 'chmod 600 ~a' to fix this." newline)
+            program-path
+            program-path)
 
-   'permissions-fixed        (list (format "'~a''s permissions were successfully fixed." program-path))
+    'init-cancelled
+    (format "Cancelled the creation of '~a'." program-path)
 
-   'file-created             (list (format "'~a' was successfully created." program-path))
+    'init-prompt
+    (format (string-append "~a will create '~a'." newline
+                           "Is this okay? [y/n]")
+            program-name
+            program-path)
 
-   'not-found-prompt         (list (format "'~a' wasn't found." program-path)
-                                           "Would you like to create it? [y/n]")
+    'file-created
+    (format "Successfully created ~a." program-path)
 
-   'error-option             (list "Error: '~a' is not an option.")
+    'empty-list
+    "There is nothing in your list."))
 
-   'empty-list               (list "There is nothing in your list.")
+(define formatees
+  (hash
+    'error-not-an-option
+    (string-append "Error: '~a' is not an option." newline
+                   "Please choose 'y' or 'n'.")
 
-   'added                    (list "Added '~a' to your list.")
+    'error-not-a-number
+    (string-append "Error: '~a' is not a number.")
 
-   'removed                  (list "Removed '~a' from your list.")))
+    'added
+    "Added '~a' to your list."
+
+    'removed
+    "Removed '~a' from your list."))
 
 ;; ------------------------------------------------
 ;; helpers
 ;; ------------------------------------------------
 (define (messages-ref key)
-  (map (lambda (element) (string-append message-prefix element))
-       (hash-ref messages key)))
+  (hash-ref messages key))
 
-(define-syntax-rule (displayln-message-format key string ...)
-  (let ([string-to-format (string-join (messages-ref key) "\n")])
-    (displayln (format string-to-format string ...))))
+(define (formatees-ref key)
+  (hash-ref formatees key))
 
-(define (displayln-message-list key)
-  (let ([listof-strings (messages-ref key)])
-    (for ([string listof-strings])
-      (displayln string))))
+(define (displayln-messages-ref key)
+  (let ([message (messages-ref key)])
+    (displayln message)))
 
-(define (displayln-for . strings)
-  (for ([string strings])
-    (displayln string)))
+(define (displayln-formatees-ref key string)
+  (let* ([formatee           (formatees-ref key)]
+         [formatee-formatted (format formatee string)])
+    (displayln formatee-formatted)))
 
-(define (file-has-correct-permissions? file)
-  (equal? correct-permissions (file-or-directory-permissions file 'bits)))
+(define (create-file string)
+  (close-output-port
+    (open-output-file string)))
 
 ;; ------------------------------------------------
-;; repair
+;; Check conditions
 ;; ------------------------------------------------
-(define (repair/not-an-option user-input)
-  (displayln-message-format 'error-option user-input)
-  (exit))
-
-(define (repair/cancel)
-  (displayln-message-list 'cancel-creation)
-  (exit))
-
-(define (repair/fake-file)
-  (displayln-message-list 'error-fake-file)
-  (exit))
-
-(define (repair/create-exit-mode key)
-  (match key
-    [(or 'ls 'rm) (exit)]
-    ['add         'do-nothing]))
-
-(define (repair/fix-permissions key)
-  (file-or-directory-permissions program-path correct-permissions)
-  (displayln-message-list 'permissions-fixed)
-  (repair/create-exit-mode key))
-
-(define (repair/wrong-permissions key)
-  (displayln-message-list 'error-permissions-prompt)
-  (display message-prefix)
-  (let ([user-input (read-line)])
-    (case (string->symbol user-input)
-      ['y   (repair/fix-permissions key)]
-      ['n   (repair/cancel)]
-      [else (repair/not-an-option user-input)])))
-
-(define (repair/create-file key)
-  (close-output-port (open-output-file program-path))
-  (file-or-directory-permissions program-path correct-permissions)
-  (displayln-message-list 'file-created)
-  (repair/create-exit-mode key))
-
-(define (repair/not-found key)
-  (displayln-message-list 'not-found-prompt)
-  (display message-prefix)
-  (let ([user-input (read-line)])
-    (case (string->symbol user-input)
-      ['y   (repair/create-file key)]
-      ['n   (repair/cancel)]
-      [else (repair/not-an-option user-input)])))
-
-(define (repair key)
+(define (check-conditions)
   (cond
     [(directory-exists? program-path)
-     (repair/fake-file)]
+     (begin (displayln-messages-ref 'error-fake-file-exists)
+            (exit))]
 
     [(not (file-exists? program-path))
-     (repair/not-found key)]
+     (begin (displayln-messages-ref 'error-file-doesnt-exist)
+            (exit))]
 
-    [(not (file-has-correct-permissions? program-path))
-     (repair/wrong-permissions key)]
+    [(not (equal? program-permissions
+                  (file-or-directory-permissions program-path 'bits)))
+     (displayln-messages-ref 'warning-permissions)]
 
     [else 'do-nothing]))
 
+;; ------------------------------------------------
+;; init
+;; ------------------------------------------------
+(define (init/create-file)
+  (create-file program-path)
+  (file-or-directory-permissions program-path
+                                 program-permissions)
+  (displayln-messages-ref 'file-created))
+
+(define (init/cancel)
+  (displayln-messages-ref 'init-cancelled)
+  (exit))
+
+(define (init/prompt)
+  (displayln-messages-ref 'init-prompt)
+  (display "> ")
+  (let* ([input        (read-line)]
+         [input-symbol (string->symbol input)])
+    (case input-symbol
+      ['y   (init/create-file)]
+      ['n   (init/cancel)]
+      [else (displayln-formatees-ref 'error-not-an-option input)])))
+
+(define (init)
+  (cond
+    [(file-exists? program-path)
+     (displayln-messages-ref 'error-file-already-exists)]
+
+    [(directory-exists? program-path)
+     (displayln-messages-ref 'error-fake-file-exists)]
+
+    [else (init/prompt)]))
+
 ;; ------------------------------------------------
 ;; ls
 ;; ------------------------------------------------
 (define (ls/display-list listof-items)
-  ;; add1 starts the listof-numbers at 1 instead of 0
+  ;; The add1 in the first binding starts the
+  ;; listof-numbers at 1 instead of 0 to make the
+  ;; list numbering more human-friendly
   (let* ([listof-numbers        (map add1 (range (length listof-items)))]
          [listof-number-strings (map number->string listof-numbers)]
          [combine-lists         (lambda (a b) (string-append a ". " b))]
@@ -171,13 +183,13 @@
                                      listof-number-strings
                                      listof-items)])
     (for ([item listof-numbered-items])
-      (displayln item))))
+         (displayln item))))
 
 (define (ls)
-  (repair 'ls)
+  (check-conditions)
   (let ([listof-items (file->lines program-path)])
     (if (null? listof-items)
-        (displayln-message-list 'empty-list)
+        (displayln-messages-ref 'empty-list)
         (ls/display-list listof-items))))
 
 ;; ------------------------------------------------
@@ -189,93 +201,111 @@
     (display-lines-to-file list-without-item
                            program-path
                            #:exists 'truncate)
-    (displayln-message-format 'removed item-to-remove)))
+    (displayln-formatees-ref 'removed item-to-remove)))
 
-(define (rm string)
-  (repair 'rm)
+(define (rm/process-string string)
   (let* ([listof-items (file->lines program-path)]
-         ;; subtract 1 because the index starts at
-         ;; 0 under the hood, but the numbers presented from 'ls'
-         ;; start at 1.
-         [item-number       (string->number string)]
-         [item-number-sub1  (sub1 item-number)]
-         [list-length       (length listof-items)])
+         [item-number      (string->number string)]
+         ;; Subtract 1 from the user's original number,
+         ;; because we want to convert the number from
+         ;; human numbers (1 2 3) to index numbers
+         ;; (0 1 2)
+         [item-number-sub1 (sub1 item-number)]
+         [list-length      (length listof-items)])
     (if (and (not (null? listof-items))
              (number? item-number)
              (positive? item-number)
-             ;; 1 less than length, because we want to
-             ;; remove the index number, which is one less
-             ;; than the item the user chose
+             ;; Don't allow numbers that are equal to
+             ;; or greater than list-length, because
+             ;; the list index starts at 0
+             ;;
              ;; Example:
-             ;; We have a list length of 3:
-             ;; '(1 2 3)
-             ;; `list-ref` in rm/remove-item above
-             ;; uses an index that starts at 0, so
-             ;; the index of the numbers above are:
-             ;; '(0 1 2)
-             ;; The 2 is the last index number in a
-             ;; list of length 3, which is what we
-             ;; want, because if you try to remove
-             ;; an index larger than 2, such as the
-             ;; list length 3, then that would be
-             ;; an error
+             ;; Length of (1 2 3) = 3
+             ;;
+             ;; To reference the highest number, we
+             ;; use (list-ref (1 2 3) 2)
              (< item-number-sub1 list-length))
         (rm/remove-item listof-items item-number-sub1)
-        (displayln-message-list 'item-not-found))))
+        (displayln-messages-ref 'error-item-not-found))))
+
+(define (rm string)
+  (check-conditions)
+  (if (string->number string)
+      (rm/process-string string)
+      (displayln-formatees-ref 'error-not-a-number string)))
 
 ;; ------------------------------------------------
 ;; add
 ;; ------------------------------------------------
-;; The string-cleaned and -remade is incase there
-;; are multiple newline characters. This ensures
-;; there is only one newline character.
 (define (add string)
-  (repair 'add)
+  (check-conditions)
+  ;; The removing and adding of the '\n' is to
+  ;; ensure only one '\n' exists at the end of the
+  ;; item to be added.
   (let* ([string-no-newline (string-replace string "\n" "")]
          [string-newline    (string-append string-no-newline "\n")])
     (display-to-file string-newline
                      program-path
                      #:exists 'append)
-    (displayln-message-format 'added string-no-newline)))
+    (displayln-formatees-ref 'added string-no-newline)))
 
 ;; ------------------------------------------------
 ;; help
 ;; ------------------------------------------------
 (define (help)
-  (displayln-for
-   "Usage:"
-   (format "  ~a [<command>] [<args>]" program-name)
-   ""
-   "Commands:"
-   (format "  ~a - Adds an item to your list." add-command)
-   (format "  ~a - Prints a numbered list of your items." ls-command)
-   (format "  ~a - Removes an item from your list." rm-command)
-   ""
-   "Examples:"
-   (format "  ~a ~a \"Go for a walk\"" program-name add-command)
-   (format "  ~a ~a" program-name ls-command)
-   (format "  ~a ~a 2" program-name rm-command)))
+  (displayln
+    (string-append
+    "Usage:" newline
+    (format "  ~a [<command>] [<args>]" program-name)
+    double-newline
+
+    "Commands:" newline
+    (format "  ~a - Creates your list." init-command) newline
+    (format "  ~a - Adds an item to your list." add-command) newline
+    (format "  ~a - Prints a numbered list of your items." ls-command) newline
+    (format "  ~a - Removes an item from your list." rm-command)
+    double-newline
+
+    "Examples:" newline
+    (format "  ~a ~a" program-name init-command) newline
+    (format "  ~a ~a \"Go for a walk\"" program-name add-command) newline
+    (format "  ~a ~a" program-name ls-command) newline
+    (format "  ~a ~a 2" program-name rm-command))))
 
 (define (process-args vectorof-args)
   (define (args-ref number)
     (vector-ref vectorof-args number))
   (match vectorof-args
-    ;; Proper usage
-    [(or '#("-h")
-         '#("--help")
-         '#("help"))     (help)]
-    [(vector "add" _)    (add (args-ref 1))]
-    [(vector "rm"  _)    (rm  (args-ref 1))]
-    [(vector "ls" )      (ls)]
-    ;; Improper usage
-    ;; This is checked so we can give the user hints on how to
-    ;; use the software if they have part of the command
-    ;; correct
-    [(vector "ls" _)     (displayln-message-list 'error-ls)]
-    [(vector "add")      (displayln-message-list 'error-add)]
-    [(vector "rm")       (displayln-message-list 'error-rm)]
-    [(or (vector)
-         (vector _ ...)) (displayln-message-list 'error-usage)]))
+    [(vector a)
+     (cond
+       [(ormap (lambda (x) (equal? a x))
+               (list help-command-1
+                     help-command-2
+                     help-command-3))
+        (help)]
+
+       [(equal? a ls-command)
+        (ls)]
+
+       [(equal? a init-command)
+        (init)]
+
+       [else (displayln-messages-ref 'error-incorrect-usage)])]
+
+    [(vector a _)
+     (cond
+       [(equal? a add-command)
+        (add (args-ref 1))]
+
+       [(equal? a rm-command)
+        (rm (args-ref 1))]
+
+       [else (displayln-messages-ref 'error-incorrect-usage)])]
+
+    [(vector _ _ _ ...)
+     (displayln-messages-ref 'error-too-many-arguments)]
+
+    [_ (ls)]))
 
 (define (main vectorof-args)
   (process-args vectorof-args))