completed

src/main/java/rocks/zipcode/AlphaCharDocument.java

 package rocks.zipcode;
 
+
+import java.io.FileWriter;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 
 /**
  * @author leon on 16/11/2018.
  */
 public class AlphaCharDocument extends Document {
+
     public AlphaCharDocument(String fileName) throws IOException {
         super(fileName);
+        FileWriter fileWriter = new FileWriter(fileName);
     }
 
     @Override
-    public void write(String contentToBeWritten) {
-    }
+    public void write(String contentToBeWritten) throws IllegalArgumentException  {
+
+                if (isAlpha(contentToBeWritten)) {
+
+                    System.out.println("inside Alpha Write being - ");
+                    super.write(contentToBeWritten);
+                    System.out.println("after write completed - ");
+                }else {
+                    throw new IllegalArgumentException(" It' not Alpa" );
+                }
+
+
+            }
+
 
     private Boolean isAlpha(String s) {
-        return null;
+        try {
+
+           String str = super.read();
+            //super.write(s);
+           System.out.println("inside isAlpha - " );
+           if(str.contains(s) ){
+               System.out.println("inside isAlpha -  inside if (string has alpha), will return true" );
+
+               return true;
+           }
+       }catch (Exception  e){
+           e.printStackTrace();
+       }
+      System.out.println("inside isAlpha -  No Alpha characters, will return false" );
+
+        return false;
+
+
+
     }
-}
+}

src/main/java/rocks/zipcode/Document.java

 
 import java.io.*;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * @author leon on 16/11/2018.
 
     @Override
     public void write(String contentToBeWritten) {
+        try {
+            fileWriter.write(contentToBeWritten);
+            fileWriter.flush();
+            //fileWriter.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+
+        }
+
     }
 
     @Override
     public void write(Integer lineNumber, String valueToBeWritten) {
+//
+        try {
+            StringBuilder sb=new StringBuilder() ;
+            try {
+                BufferedReader  fileReader =new BufferedReader( new FileReader( file)) ;
+                String fileread ="";
+                int i=0;
+                while((fileread =fileReader.readLine()) !=null){
+                    if(lineNumber==i) {
+                        sb.append(valueToBeWritten);
+                    } else {
+                        sb.append(fileread);
+                    }
+                    sb.append("\n");
+                    i++;
+                }
+                overWrite(sb.toString());
+            }catch (Exception e) {
+                e.printStackTrace();
+            }
+
+
+
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 
     @Override
     public String read(Integer lineNumber) {
-        return null;
+        try {
+            //return new String(Files.readAllBytes(Paths.get(file.getPath())));
+            String str = new String(Files.readAllLines(Paths.get(file.getPath())).get(lineNumber));
+            return str;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+
     }
 
     @Override
     public String read() {
-        return null;
+
+        StringBuilder sb=new StringBuilder() ;
+        try {
+          BufferedReader  fileReader =new BufferedReader( new FileReader( file)) ;
+           String fileread ="";
+            while((fileread =fileReader.readLine()) !=null){
+            sb.append(fileread);
+            sb.append("\n") ;
+
+        } }catch (Exception e) {
+            e.printStackTrace();
+        }
+        return sb.toString().trim() ;
+//        try {
+//            return new String(Files.readAllBytes(Paths.get(file.getPath())));
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            return null;
+//        }
+
     }
 
+
     @Override
-    public void replaceAll(String stringToReplace, String replacementString) {
-    }
+    public void replaceAll(String stringToReplace, String replacementString) {  //NOT WORKING
+        try{
+
+
+        String strFileInputs = read();
+            System.out.println("Inside replaceAll method -  After reading the input - " + strFileInputs );
+            Pattern ptn = Pattern.compile(stringToReplace );
+            Matcher mtch = ptn.matcher(strFileInputs  );
+            String replaced=mtch.replaceAll(replacementString );
 
+        overWrite(replaced ) ;
+
+            }catch (Exception e ){
+                e.printStackTrace() ;
+            }
+
+    }
     @Override
     public void overWrite(String content) {
+
+        try {
+
+            FileWriter fstream = new FileWriter(file, false);
+            fstream.write(content);
+            fstream.flush();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
     }
 
     public List<String> toList() {
-        return null;
+
+        List<String> list = null;
+        try (Stream<String> lines = Files.lines(Paths.get(file.getPath()))) {
+            list = lines.collect(Collectors.toList());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return list;
     }
 
     @Override
     public File getFile() {
-        return null;
+        try {
+            String str = "";
+            ClassLoader cl = getClass().getClassLoader();
+            File file = new File(cl.getResource(str).getFile());
+            return file;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
     }
 
     @Override
     public String toString() {
-        return null;
+        try {
+            StringBuilder sb=new StringBuilder() ;
+            String filepath=file.toString() ;
+            String str= new String(Files.readAllBytes(Paths.get(file.getPath())));
+            sb.append(filepath ) ;
+            sb.append( "{");
+            sb.append(str) ;
+            sb.append("}");
+
+            return sb.toString() ;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
     }
 }

src/main/java/rocks/zipcode/NumericCharDocument.java

 package rocks.zipcode;
 
+import java.io.BufferedReader;
+import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 
 /**
  * @author leon on 16/11/2018.
 public class NumericCharDocument extends Document {
     public NumericCharDocument(String fileName) throws IOException {
         super(fileName);
+
     }
 
     @Override
-    public void write(String contentToBeWritten) {
+    public void write(String contentToBeWritten) throws IllegalArgumentException {
+        if (isNumeric(contentToBeWritten) ) {
+           // System.out.println("inside Alpha Write being - ");
+            super.write(contentToBeWritten);
+            System.out.println("after write completed - ");
+        }else {
+            throw new IllegalArgumentException(" It' not Alpha" );
+        }
+
     }
 
     private Boolean isNumeric(String s) {
-        return null;
+        try{
+
+            String str = super.read();
+            //super.write(s);
+            System.out.println("inside isAlpha - " );
+            if(str.contains(s) ){
+                System.out.println("inside isAlpha -  inside if (string has alpha), will return true" );
+
+                return true;
+            }
+        }catch (Exception  e){
+            e.printStackTrace();
+        }
+        System.out.println("inside isAlpha -  No Alpha characters, will return false" );
+
+        return false;
+
+
     }
 }

src/main/java/rocks/zipcode/SpecialCharDocument.java

 package rocks.zipcode;
 
+import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @author leon on 18/11/2018.
  */
 public class SpecialCharDocument extends Document {
     public SpecialCharDocument(String fileName) throws IOException {
-        super(fileName);
+        super(new File(fileName));
     }
 
     @Override
     public void write(String contentToBeWritten) {
-    }
+
+            if (isSpecialCharacters(contentToBeWritten) ) {
+
+                super.write(contentToBeWritten);
+               // System.out.println("after write completed - ");
+            } else {
+                throw new IllegalArgumentException(" It' not Alpa");
+            }
+
+
+        }
 
     private Boolean isSpecialCharacters(String s) {
-        return null;
+        try{
+
+            String str = super.read();
+            //super.write(s);
+            System.out.println("inside isAlpha - " );
+            if(str.contains(s) ){
+                System.out.println("inside isAlpha -  inside if (string has alpha), will return true" );
+
+                return true;
+            }
+        }catch (Exception  e){
+            e.printStackTrace();
+        }
+        System.out.println("inside isAlpha -  No Alpha characters, will return false" );
+
+        return false;
+
+
     }
 }

src/test/java/rocks/zipcode/alphadocument/AlphaDocumentWriteTest.java

 package rocks.zipcode.alphadocument;
 
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import rocks.zipcode.AlphaCharDocument;
 import rocks.zipcode.Document;
  */
 public class AlphaDocumentWriteTest {
 
+    @Before
+    public void setUp() throws Exception {
+
+    }
+
     @Test(expected = IllegalArgumentException.class)
     public void writeNumericValuesToFile() throws IOException {
         // given
         String contentToBeWritten = "123";
         Document documentWriter = new AlphaCharDocument(fileName);
 
+
         // when
         documentWriter.write(contentToBeWritten);
     }

src/test/java/rocks/zipcode/numericdocument/NumericDocumentWriteTest.java

  */
 public class NumericDocumentWriteTest {
 
-    @Test
+    @Test (expected = IllegalArgumentException.class)
     public void writeNumericValuesToFile() throws IOException {
         // given
         String fileName = "target/file.txt";
 
         // when
         documentWriter.write(contentToBeWritten);
+
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void writeSpecialCharacter() throws IOException {
+    public void writeSpecialCharacter() throws IOException,IllegalArgumentException {
         // given
         String fileName = "target/file.txt";
         String contentToBeWritten = "()";
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void writeAlphaValuesTest() throws IOException {
+    public void writeAlphaValuesTest() throws IOException, IllegalArgumentException {
         // given
         String fileName = "target/file.txt";
         String expected = "The quick brown foxy";

src/test/java/rocks/zipcode/specialdocument/SpecialCharDocumentTest.java

 
         // when
         documentWriter.write(contentToBeWritten);
+
     }
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
     public void writeSpecialCharacter1() throws IOException {
         // given
         String fileName = "target/file.txt";
     }
 
 
-    @Test
+    @Test(expected = IllegalArgumentException.class)
     public void writeSpecialCharacter2() throws IOException {
         // given
         String fileName = "target/file.txt";