Phase02 clean code corrected

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.configuration.updateBuildConfiguration": "interactive"
+}

phase01_search/pom.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.example</groupId>
+    <artifactId>phase01_search</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+    <!-- Other dependencies -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.30</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+
+</project>

phase01_search/src/main/java/com/example/EntryStructure.java

@@ -0,0 +1,17 @@
+package com.example;
+
+import java.util.HashSet;
+import java.util.Set;
+import lombok.Getter;
+
+public class EntryStructure {
+    @Getter
+    private String word;
+    @Getter
+    private Set<String> fileNames = new HashSet<String>();
+
+    public EntryStructure(String word, Set<String> fileNames) {
+        this.word = word;
+        this.fileNames = fileNames;
+    }
+}

phase01_search/src/main/java/com/example/FileReader.java

@@ -0,0 +1,28 @@
+package com.example;
+
+import java.nio.file.*;
+import java.util.ArrayList;
+
+public class FileReader {
+    public static ArrayList<String> getFileNames(String path){
+        ArrayList<String> fileNames = new ArrayList<String>();
+        Path folder = Paths.get(path);
+
+        if (Files.isDirectory(folder)) {
+            try {  
+                DirectoryStream<Path> directoryStream = Files.newDirectoryStream(folder);
+                for (Path filePath : directoryStream) {
+
+                    fileNames.add(String.valueOf(filePath.getFileName()));
+                }
+                directoryStream.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            System.out.println("Specified path is not a directory.");
+        }
+
+        return fileNames;
+    }
+}

phase01_search/src/main/java/com/example/Main.java

@@ -0,0 +1,122 @@
+package com.example;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.Map;
+
+public class Main {
+
+    // Searchs a word in inverted index then returns name of files that are containing that word
+    public static Set<String> searchWord(String word, Map<String, Set<String>> invertedIndex) {
+        return invertedIndex.getOrDefault(word, Collections.emptySet());
+    }
+
+    public static void main(String[] args) {
+
+        // Getting directory path and user input
+        Scanner myScanner = new Scanner(System.in);
+
+        System.out.print("Enter Data Folder Path: ");
+        final String directoryPath = myScanner.nextLine();
+
+        System.out.print("Enter Search Query: ");
+        final String userInput = myScanner.nextLine();
+
+        // Finding name of all files that are in EnglishData directory
+        ArrayList<String> fileNamesInFolder = FileReader.getFileNames(directoryPath);
+
+        // Reading files that are in data direcotry and constructing inverted index table
+        Map<String, Set<String>> invertedIndex = new HashMap<>();
+
+        for (String fileName : fileNamesInFolder) {
+            try {
+                File file = new File(directoryPath + "/" + fileName);
+                Scanner myReader = new Scanner(file);
+
+                while (myReader.hasNextLine()) {
+                    Set<String> documentIds = new HashSet<String>();
+                    documentIds.add(fileName);
+
+                    String data = myReader.nextLine();
+                    String[] splittedData = data.split(" ");
+
+                    for (String word : splittedData) {
+                        // Ignoring empty words
+                        if (word == "") {
+                            continue;
+                        }
+                        // Inserting new entry to inverted index table
+                        invertedIndex.computeIfAbsent(word, k -> new HashSet<>()).addAll(documentIds);
+                    }
+                }
+                myReader.close();
+            } catch (FileNotFoundException e) {
+                System.out.println("An error occurred.");
+                e.printStackTrace();
+            }
+        }
+
+        // Splitting user input to undrestand the command
+        String[] userInputWords = userInput.split(" ");
+
+        ArrayList<String> necessaryWords = new ArrayList<String>();
+        ArrayList<String> orWords = new ArrayList<String>();
+        ArrayList<String> notWords = new ArrayList<String>();
+
+        // Categorizing command words into orWords, necessary and forbidden groups
+        for (String word : userInputWords) {
+            if (word.startsWith("+")) {
+                word = word.replace('+', ' ').trim();
+                orWords.add(word);
+            } else if (word.startsWith("-")) {
+                word = word.replace('-', ' ').trim();
+                notWords.add(word);
+            } else {
+                necessaryWords.add(word);
+            }
+        }
+        myScanner.close();
+
+        // Initializing some sets for forming final answer
+        Set<String> necessaryFiles = new HashSet<String>();
+        Set<String> forbiddenFiles = new HashSet<String>();
+        Set<String> orFiles = new HashSet<String>();
+
+        // Finding intersection between necessary words' file names
+        for (String nWord : necessaryWords) {
+            if(necessaryFiles.isEmpty()){
+                necessaryFiles.addAll(searchWord(nWord, invertedIndex));
+            }
+            else{
+                necessaryFiles.retainAll(searchWord(nWord, invertedIndex));
+            }
+        }
+
+        // Finding all orWords' file names
+        for (String orWord : orWords) {
+            orFiles.addAll(searchWord(orWord, invertedIndex));
+        }
+
+        // Finding all forbidden words' file names
+        for (String notWord : notWords) {
+            forbiddenFiles.addAll(searchWord(notWord, invertedIndex));
+        }
+
+        // Final answer is intersection between necessary files and orFiles - forbidden files
+        Set<String> intersection = new HashSet<>(necessaryFiles);
+        intersection.retainAll(orFiles);
+        intersection.removeAll(forbiddenFiles);
+
+        //Printing the result
+        System.out.println("Results: ");
+        for (String entry : intersection) {
+            System.out.println(entry);
+        }
+    }
+}

phase01_search/target/maven-archiver/pom.properties

@@ -0,0 +1,3 @@
+artifactId=phase01_search
+groupId=com.example
+version=1.0-SNAPSHOT

phase01_search/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -0,0 +1,3 @@
+C:\Users\mhda1\Documents\VSCode\Fall1402-TwoWeek-InternShip-Backend\phase01_search\src\main\java\com\example\FileReader.java
+C:\Users\mhda1\Documents\VSCode\Fall1402-TwoWeek-InternShip-Backend\phase01_search\src\main\java\com\example\EntryStructure.java
+C:\Users\mhda1\Documents\VSCode\Fall1402-TwoWeek-InternShip-Backend\phase01_search\src\main\java\com\example\Main.java

phase02_clean_code/pom.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.example</groupId>
+    <artifactId>phase02_clean_code</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+    <!-- Other dependencies -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.30</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>exec-maven-plugin</artifactId>
+                <version>3.1.1</version>
+                <configuration>
+                    <mainClass>com.example.Main</mainClass>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
+</project>

phase02_clean_code/src/main/java/com/example/EntryStructure.java

@@ -0,0 +1,17 @@
+package com.example;
+
+import java.util.HashSet;
+import java.util.Set;
+import lombok.Getter;
+
+public class EntryStructure {
+    @Getter
+    private String word;
+    @Getter
+    private Set<String> fileNames = new HashSet<String>();
+
+    public EntryStructure(String word, Set<String> fileNames) {
+        this.word = word;
+        this.fileNames = fileNames;
+    }
+}

phase02_clean_code/src/main/java/com/example/FileReader.java

@@ -0,0 +1,24 @@
+package com.example;
+
+import java.nio.file.*;
+import java.util.ArrayList;
+
+public class FileReader {
+    public ArrayList<String> getFileNames(String path){
+        ArrayList<String> fileNames = new ArrayList<String>();
+        Path folder = Paths.get(path);
+
+        try {  
+            DirectoryStream<Path> directoryStream = Files.newDirectoryStream(folder);
+            for (Path filePath : directoryStream) {
+
+                fileNames.add(String.valueOf(filePath.getFileName()));
+            }
+            directoryStream.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return fileNames;
+    }
+}

phase02_clean_code/src/main/java/com/example/FinalSearchResult.java

@@ -0,0 +1,25 @@
+package com.example;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class FinalSearchResult {
+    private Set<String> necessaryFiles;
+    private Set<String> orFiles;
+    private Set<String> forbiddenFiles;
+
+    FinalSearchResult(Set<String> givenNecessaryFiles, Set<String> givenOrFiles, Set<String> givenForbiddenFiles){
+        this.necessaryFiles = givenNecessaryFiles;
+        this.orFiles = givenOrFiles;
+        this.forbiddenFiles = givenForbiddenFiles;
+    }
+
+    public Set<String> giveFinalResult(){
+        // Final answer is intersection between necessary files and orFiles - forbidden files
+        Set<String> intersection = new HashSet<>(necessaryFiles);
+        intersection.retainAll(orFiles);
+        intersection.removeAll(forbiddenFiles);
+
+        return intersection;
+    }
+}

phase02_clean_code/src/main/java/com/example/ForbiddenWordSearchResult.java

@@ -0,0 +1,16 @@
+package com.example;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+public class ForbiddenWordSearchResult {
+    public Set<String> getForbiddenWordsSearchResult(String[] splittedSearchQuery, InvertedIndex invertedIndex){
+        UnnecessaryWordCategorizer unnecessaryWordCategorizer = new UnnecessaryWordCategorizer();
+        ArrayList<String> forbiddenWords = unnecessaryWordCategorizer.categorizer(splittedSearchQuery, "-");
+
+        UnnecessaryFileNameCategorizer unnecessaryFileNameCategorizer = new UnnecessaryFileNameCategorizer();
+        Set<String> forbiddenFiles = unnecessaryFileNameCategorizer.categorizer(invertedIndex, forbiddenWords);
+
+        return forbiddenFiles;
+    }
+}

phase02_clean_code/src/main/java/com/example/InvertedIndex.java

@@ -0,0 +1,51 @@
+package com.example;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.Set;
+
+import lombok.Getter;
+
+public class InvertedIndex {
+    @Getter
+    private Map<String, Set<String>> invertedIndex;
+
+    InvertedIndex(){
+        this.invertedIndex = new HashMap<>();
+    }
+
+    public void constructInvertedIndexFromFolder(String directoryPath, ArrayList<String> fileNamesInFolder){
+        for (String fileName : fileNamesInFolder) {
+            try {
+                File file = new File(directoryPath + "/" + fileName);
+                Scanner myReader = new Scanner(file);
+
+                while (myReader.hasNextLine()) {
+                    Set<String> documentIds = new HashSet<String>();
+                    documentIds.add(fileName);
+
+                    String data = myReader.nextLine();
+                    String[] splittedData = data.split(" ");
+
+                    for (String word : splittedData) {
+                        // Ignoring empty words
+                        if (word == "") {
+                            continue;
+                        }
+                        // Inserting new entry to inverted index table
+                        invertedIndex.computeIfAbsent(word, k -> new HashSet<>()).addAll(documentIds);
+                    }
+                }
+                myReader.close();
+            } catch (FileNotFoundException e) {
+                System.out.println("An error occurred.");
+                e.printStackTrace();
+            }
+        }
+    }
+}