CS 211 Project 3: Class Inhairytense

• JUnit test cases will be provided to detect errors in your code.
• Tests may not be available on initial release but will be posted at a later time.
• Tests may be expanded, changed, and corrected as the deadline approaches.
• It is your responsibility to get and use the freshest set of tests available.
• Tests will be provided in source form so that you will know what tests are doing and where you are failing.
• It is up to you to run the tests to determine whether you are passing or not. If your code fails to compile against the tests, little to no credit will be garnered for this section.
• Most of the credit will be divide evenly among the tests; e.g. 50% / 25 tests = 2% per test. However, the teaching staff reserves the right to adjust the weight of test cases after the fact if deemed necessary.
• Code that does not compile and run tests according to the specified command line invocation may lose all automated testing credit. Graders will usually try to fix small compilation errors such as bad directory structures or improper use of packages. Such corrections typically result in a loss of 5-10% credit on automated testing. However, if more than a small amount of error to fix problems seems required, no credit will be given.

• Teaching staff (GTAs) will manually inspect your work looking for a specific set of features. They are generally listed throughout the document next to the relevant project features.
• Credit will also be awarded/deducted based on adherence to good coding style, which includes:
  • Good indentation and curly brace placement (be consistent and follow a common convention)
  • Comments describing each field and method
  • Comments describing a complex section of code and invariants which must be maintained for classes
  • Use of internal private methods to decompose the problem beyond what is required in the spec, as needed
• Some credit will be assigned for designing your program according to the given specification, for instance using a designated algorithm, structuring your program in a certain fashion, or utilizing a required programming element.

public class Document{
// Simple, editable document. Contents are initialized with a
// string. Allows scanning through the document by word with calls to
// nextWord() and hasNextWord() with rewind() resetting back to the
// beginning of the document.  Words can be replaced via calls to
// replaceLastWord(str). Display contents with toString() and
// debugString().

  public Document(String contents);
  // Construct a document with the given contents

  public Document(File file) throws Exception;
  // Construct a document contents initialized from the given file

  public String toString();
  // Returns a string representation of the entire document

  public String debugString();
  // Returns a string representation of the document with the contents
  // modified to mark the word selected by nextWord()

  public String nextWord();
  // Return the next word in the document starting with the first
  // word. Ignores punctuation and numbers. Throws an exception if
  // there are no words remaining in the document.

  public boolean hasNextWord();
  // Return true if the document contains any more words so that a
  // call to nextWord() would succeed. Returns false if no words
  // remain in the document.  Punctuation and numbers do not count as
  // words.

  public void rewind();
  // Reset the internal position of the document so that a subsequent
  // call to nextWord() will return the first word in the document

  public void replaceLastWord(String correction);
  // Replace the last word returned by nextWord() with the given
  // correction.  Internal positioning will be adjusted so that
  // subsequent calls to nextWord() will move beyond the supplied
  // correction. Throws an exception if nextWord() has not been called
  // appropriately (ex: immediately after construction or after a call
  // to rewind())

  public String currentLine();
  // Return a string showing the line of the document which contains
  // the last word returned by nextWord().  Returns the first line of
  // the document if called after construction or a call to rewind().

}

Below is a demonstration of several of the capabilities of the SpellChecker.

Welcome to DrJava.
> // Demonstrate spell checker capabilities

> // Construct a spell checker with the provided english dictionary ignoring case
> SpellChecker sc = new SpellChecker("english-dict.txt",true);

> sc.dictSize()                   // show # words in dictionary
119095
> sc.isCorrect("potatoes")        // is word in the dictionary
true
> sc.correctWord("potatoes")      // provide a correction for word
**potatoes**

> sc.isCorrect("potatoe")         // is word in the dictionary
false
> sc.correctWord("potatoe")       // provide a correction for word
**potatoe**
> sc.correctWord("tumato")        // provide a correction for word
**tumato**
> sc.correctWord("misunderestimated")
**misunderestimated**

> // Create a document
> String content = "One potatoe, two tumatoes, three potatoes, four. I misunderestimated how many potatoes."
> Document doc = new Document(content)

> // "Correct" misspellings in the document by highlighting them
> sc.correctDocument(doc)
> doc.toString()
One **potatoe**, two **tumatoes**, three potatoes, four. I **misunderestimated** how many potatoes.

> // Read all lines from a file using a static method
> String [] lines = SpellChecker.readAllLines("english-dict.txt");
> lines[0]
A
> lines[5]
aah
> lines.length
119095

public class SpellChecker{
// A class to do spell checking. This version only marks misspelled words with
// asterisks as in **mispeling**.  It serves as a parent class for other spell
// checkers to inherit functionality to add features by overriding methods.

  protected String [] dictWords;      
  // Array of words considered correct by spell checker

  protected boolean ignoreCase;
  // If true, ignore case when checking the spelling of words; otherwise
  // capitalization differences will be counted as misspellings

  public static String [] readAllLines(String filename);
  // Utility which reads all lines from a file and returns them as an array of
  // strings. If problems are encountered during reading, return a string array
  // of length 0 (empty).  See implementation notes for dicussion of how to
  // handle exceptions and use two-pass scanning to allocate an appropriately
  // sized array.

  public SpellChecker(String dictFilename, boolean ignoreCase);
  // Construct a spellchecker. dictFilename is the name of a file containing all
  // words that are considered correct, one on each line; english-dict.txt is
  // commonly used.  ignoreCase indicates whether case should be ignored or used
  // when checking for word correctness against dictionary words.

  public int dictSize();
  // Return the size of the dictionary used by this spellchecker which is the
  // number of words read from the dictionary file and stored in the
  // dictWords array.

  public boolean isCorrect(String word);
  // Return true if the provided word is considered correct by the spell checker
  // and false otherwise. A word is correct if it is equal to a word in the
  // dictionaryWord array. It is also correct if case is being ignored and is
  // equal ignoring case to some word in the dictWords array.

  public String correctWord(String word);
  // Create a correction for the given word.  Return the word surrounded by
  // asterisks which mark it as incorrect as in the word "misunderestimated"
  // should become "**misunderestimated**".  This method produces a correction
  // for the given word even if it is in the dictionary: it is to be used in
  // conjunction with isCorrect(word) to transform only words not in the
  // dictionary. That means correctWord("apple") returns "**apple**".

  public void correctDocument(Document doc);
  // From the beginning of the document, apply corrections to all words in the
  // document. Each misspelled word will be marked with asterisks according to
  // the correctWord() method.  Methods of Document such as nextWord(),
  // hasNextWord(), and replaceLastWord(w) are used to modify the provided
  // document.

}

• The readAllLines(filename) method uses an efficient input strategy such as the one suggested in the spec to avoid repeatedly re-allocating larger arrays while reading input. Only a single array allocation should be required.
• Exception handling is incorporated into readAllLines(filename) to return an empty array if no file is found.
• Effective use of the String methods are made to honor the ignoreCase option during isCorrect(word) calls.
• The implementation of correctDocument(doc) makes effective use of the public methods of the Document class to replace misspelled words with the results of a call to correctWord(word) which will be important for descendant classes.
• Standard arrays are employed for the dictWords rather than other more advanced data structures such as ArrayList
• The Document class is NOT used in readAllLines(..); a Scanner is instead used to read from the file
• No instances of Document are used in the SpellChecker except during the correctDocument(doc) method
• The SpellChecker has only the two fields specified in the class architecture:

  protected String [] dictWords;      
  protected boolean ignoreCase;
  

public class StringComparison {
// Class which contains some utility methods to compare strings

  public static int editDistance(String x, String y);
  // Compute the edit distance (Levenstein Distance) between strings x
  // and y; returns a positive number indicating the minimum character
  // insertions, deletions, or substitutions required to transform x
  // into y.  Smaller numbers mean x and y are "closer" to each other.
  // Uses dynamic programming to solve this task as per the algorithm
  // at
  // https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_full_matrix.
  // 
  // Possible to optimize the performance of this using the two-row
  // approach or a global matrix though both would introduce
  // complications.

}

public class AutomaticSC extends SpellChecker{
// A spell checker which automatically selects a correction for a
// misspelled word.  It inherets most functionality from its parent
// class but adjusts how correctWord(..) performs.

  public AutomaticSC(String dictFilename, boolean ignoreCase);
  // Construct an automatic spell checker. Pass the parameters to the
  // parent class constructor.

  @Override
  public String correctWord(String word);
  // Return a correction for the given word. The correction is the
  // word in the dictionary which has the smallest edit distance from
  // the given word. If there are ties, favor whichever word appears
  // earlier in the dictionary. Make use of the methods of the
  // provided StringComparison to find the closest word in the
  // dictionary. Make sure to honor the ignoreCase option which may
  // lead you to convert words to all upper or lower case.

  public static String matchCase(String model, String source);
  // Utility method to handle case matching between words. Check if
  // parameter model is all caps or only the first character is
  // capitalized and transform source to match the capitalization. In
  // the event that the model is neither all caps nor capitalized
  // followed by all lower case, return the source strnig as
  // is. Examples are given below.
  // 
  // | Situation   | model  | source | return |
  // |-------------+--------+--------+--------|
  // | All Caps    | BANANA | apple  | APPLE  |
  // | All Caps    | PEAR   | orange | ORANGE |
  // | Capitalized | Banana | orange | Orange |
  // | Capitalized | Apple  | pear   | Pear   |
  // | Neither     | banana | apple  | apple  |
  // | Neither     | banana | Apple  | Apple  |
  // | Neither     | BaNaNa | aPPle  | aPPle  |
  // | Neither     | peaR   | Orange | Orange |

}

• The constructor is very short by employing the initializtion that is performed in the parent class through use of super(..)
• Methods are not replicated from the parent class. Only the required correctWord(word) method overrides parent behavior while other methods are inherited by leaving them unspecified.
• The matchCase(..) method does clean case analysis to determine if the model paraemter is all caps, capitalized, or neither and simple transformations to the source to cause it to match.
• correctWord(word) clearly incorporates the ignoreCase field, makes use of matchCase(..), and is specified in a clean and readable fashion.

Not carefully how the Scanner stdin and PrinterWriter stdout are initialized and provided as arguments to the InteractiveSC constructor to allow the user to directly interact with the spell checker.

Also note the format of information associated with the automatic spell checker: it is preceded by the @ symbol to distinguish it from other prompts.

Welcome to DrJava.
> import java.util.*;
> import java.io.*;

> // Make initialization easy
> Scanner stdin = new Scanner(System.in);
> PrintWriter stdout = new PrintWriter(System.out,true);

> // Create an interactive spell checker using english-dict.txt
> InteractiveSC sc = new InteractiveSC("english-dict.txt",true,stdin,stdout);
> sc.isCorrect("dork")         // in the english dictionary
true


> String s;
> sc.isCorrect("dorkus")          // not in the english dictionary
false
> s = sc.correctWord("dorkus");   // prompt for adding during correction
@- Correction for **dorkus**:
dork
@ Corrected to: dork
> s
dork
> sc.isCorrect("cheese")          // in english dictionary
true
> sc.isCorrect("cheeze")          // not in english or personal dictionary
false
> s = sc.correctWord("cheeze");     // prompt for adding during correction
@- Correction for **cheeze**:
cheese
@ Corrected to: cheese
> s
cheese

> // Correct a whoel document interactively
> Document doc = new Document("One potatoe, two potatoe, three potatoe, four.");
> sc.correctDocument(doc);
@ MISSPELLING in: One **potatoe**, two potatoe, three potatoe, four.
@- Correction for **potatoe**:
potato
@ Corrected to: potato
@ MISSPELLING in: One potato, two **potatoe**, three potatoe, four.
@- Correction for **potatoe**:
potatoes
@ Corrected to: potatoes
@ MISSPELLING in: One potato, two potatoes, three **potatoe**, four.
@- Correction for **potatoe**:
potatoes
@ Corrected to: potatoes
> doc.toString()
One potato, two potatoes, three potatoes, four.

public class InteractiveSC extends SpellChecker{
// A spell checker which interactively prompts users for spelling
// corrections.  It inherets much of its functionality from
// SpellCheck but the behavior of correctWord(w) and
// correctDocument(d) is modified from the parent version.

  protected Scanner input;
  // Scanner to read input from a user. The scanner should be provided
  // in the constructor and should not be created. It may be connected
  // to System.in for true interactive use or may be fixed input in
  // from a string used for testing.

  protected PrintWriter output;
  // PrintWriter used to write output for a user. It should be
  // provided in the constructor and should not be created. It may be
  // connected to System.out to write to the screen or may write a
  // temporary buffer during tests.

  public InteractiveSC(String dictFilename, boolean ignoreCase, Scanner input, PrintWriter output);
  // Constructor for the interactive spell checker.  Arguments
  // dictFilename and ignoreCase should be used to invoke the super
  // class constructor.  The input and output parameter should be set
  // to the associatd fields of this class.

  @Override
  public String correctWord(String word);
  // Prompt the user for a correction using a prompt with the format:
  //
  // @- Correction for **potatoe**:
  //
  // where "potatoe" is replaced with the misspelled word.  Read input
  // from the user and return the provided correction.  Before
  // returning, print the correction in a message formatted:
  //
  // @ Corrected to: potato
  // 
  // Note that this method overrides the version of correctWord(w)
  // from the parent class. Like the parent version, it will produce
  // corrections irrespective of whether the given word is in the
  // dictionary.

  @Override
  public void correctDocument(Document doc);
  // Starting from the beginning of the document, apply corrections to
  // all misspelled words. When a misspelled word is found, print a
  // message and line of the document with the misspelled word
  // highlighed as in
  //
  // @ MISSPELLING in: One **potatoe**, two potatoe, three potatoe, four.
  //
  // Then prompt the user for a correction as in
  //
  // @- Correction for **potatoe**:
  // 
  // Print newlines a the end of both messages.  Printing to the
  // screen should use the output PrintWriter tracked by the
  // interactive spell checker.  Reading input should use the input
  // Scanner tracked by the spell checker.  Note that this method
  // overrides the version of correctDocument(w) from the parent
  // class.

}

• Only the required methods are overriden from the parent class; isCorrect(word) does not require modification
• Only the required new fields for the InteractSC are defined; the dictionary and treatment of case fields are inherited and do not need to be redefined.

public class PersonalSC extends InteractiveSC {
// A spell checker which allows use of a personal dictionary. The
// personal dictionary is initially read from a file though the file
// may be non-existen in which case the personal dictioary is empty to
// begin with.  When checking for correctness of words, both the
// system dictionary and personal dictionary are checked. If a
// misspelled word is to be corrected, the user is interactively
// prompted as to whether the word should instead be added to the
// personal dictionary.  The class can save the personal dictionary
// back to the file from which it was read.

  protected String personalDictFilename;
  // Name of the file for the personal dictionary

  protected String [] personalDictWords;      
  // Personal dictionary words

  public PersonalSC(String dictFilename, boolean ignoreCase, Scanner input, PrintWriter output, String personalDictFilename);
  // Construct a spell checker with a personal, modifiable dictionary.
  // Arguments are identical to InteractiveSC except for the final
  // argument which is a file containing the personal dictionary
  // words. This file should be formatted in the same way as a normal
  // dictionary and the contents used to initially fill in the
  // personalDictWords field.

  public int personalDictSize();
  // Return the size of the personal dictionary used by this
  // spellchecker which is the size of the personalDictWords array.

  @Override
  public boolean isCorrect(String word);
  // Check if the word is correct according to the same methodology as
  // the parent class.  If not, check whether the word appears in the
  // personal dictionary associated with this spell checker. Honor the
  // ignoreCase setting when checking the personal dictionary.

  @Override
  public String correctWord(String word);
  // If the parameter word is not in the system or personal
  // dictionary, prompty the user on whether they would like to add it
  // to the dictionary as in
  //
  // @- **tumato** not in dictionary add it? (yes / no)
  //
  // If the response is "yes" (read using the spell checkers scanner),
  // append it to the personalDictWords. You may use library methods
  // from java.util.Arrays to make the append easier.  After
  // appending, return the word as it is now considered correct.
  // 
  // If the answer on whether to add is not "yes" (e.g. "no"), prompt
  // the user for a correction in the same way that the parent class does. 

  public String getAllPersonalDictWords();
  // Return a string showing all words currently in the spell checkers
  // personal dictionary, one word per line.

  public void savePersonalDict() throws Exception;
  // Write the contents of personalDictWords to the file from which
  // they were initially read (personalDictFilename).  Write one word
  // per line.  Print a message to the screen indicating the
  // dictionary has been saved in the format:
  //
  // @ Personal dictionary written to file personal-dict.txt
  //
  // where the last word on the line is the name of the file where the
  // contents are saved.

}

• It is likely that you will want a helper method to expand the array associated with personalDict. This will make the code in correctWord(word) a bit shorter and cleaner. You are free to use library methods such as those in Array for this purpose.
• It is possible that a the personal dictionary file is empty or non-existent. Use the readAllLines(filename) method to aid with this which should return an empty array if the file does not exist.
• Make sure to retain the name of the personal dictionary file as the contents of the personalDict array must be written back to that same file on a call to savePersonalDict(). The PrintWriter class is useful for file writing.
• Whenever writing files, always make sure to invoke the close() method of PrintWriter to ensure contents are actually written.

• Make effective use of the parent class version of correctWord(word) during implementation of that method
• Employ the readAllLines(filename) method to ease the task of reading in the personal dictionary.
• Clean code is present to enlarge the personalDict array to accommodate new words. Library methods are encouraged to facilitate this process.
• Standard arrays are employed for the personalDictWords rather than other more advanced data structures such as ArrayList