Commit 27982a2f authored by Alexander Ross Melnick's avatar Alexander Ross Melnick
Browse files

Resolved merge conflicts by using remote versions

parents dc027177 80bb95e4

CheckerCorrector/Checker.java

+26 −7
Original line number Diff line number Diff line
@@ -20,7 +20,12 @@ public class Checker { 
        

        ArgumentParser argPars = ArgumentParser.of(args);

        BasicGraph basicGraphClass = new BasicGraph();

        DBinterface dbInterface = new DBinterface();

        DBinterface dbInterface;

        if(!argPars.isDutch()){

            dbInterface = new DBinterface("SQLite/token_database_english.db", "SQLite/smallDic.txt");

        }else{

            dbInterface = new DBinterface("SQLite/token_database_dutch.db", "SQLite/DutchTranslation.txt");

        }

        DirectedGraph<State> graph = basicGraphClass.getGraph();

        JsonMaker jsonMaker = JsonMaker.create();
@@ -29,13 +34,22 @@ public class Checker { 
            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    String dbName = "SQLite/newdatabase.db";



                    String dbName = "SQLite/token_database_english_updated.db";

                    if(argPars.isCheckFile()){

                        dbName = argPars.getFileName();

                    }

                    new WordRoleUpdater(dbName);

                }

            });

        }else if(argPars.isUpdateTokenFromDic()){

            dbInterface.readDataFromDatabase();

            if(argPars.isDutch()){

                dbInterface.updateTokenTableFromDic("SQLite/token_database_dutch.db", "SQLite/DutchTranslation.txt", true);

            }else{

                dbInterface.updateTokenTableFromDic("SQLite/token_database_english.db", "SQLite/DutchTranslation.txt", false);

            }

            

        }else if(argPars.isUpdateToken()){

            dbInterface.readDataFromDatabase();

            if(argPars.isCheckFile()){
@@ -61,14 +75,19 @@ public class Checker { 
                    dbInterface.updateTokenInDatabase(phrase.toLowerCase(), graph);                    

                }

            }

            dbInterface.updateDatabase();

            if(argPars.isDutch()){

                dbInterface.updateDatabase("SQLite/token_database_dutch_updated.db");

            }else{

                dbInterface.updateDatabase("SQLite/token_database_english_updated.db");

            }

        }else if(argPars.isUpdateHashTable()){

            if(argPars.isCheckFile()){

                SentenceExtractor extractor = SentenceExtractor.of(argPars.getFileName());

                List<String> extractedSentences = extractor.getSentences();  

                

                try {

                    HashTableMaker manager = new HashTableMaker();

                    

                    HashTableMaker manager = new HashTableMaker("SQLite/hash_database_english.db");

                    for (String sentence : extractedSentences) {

                        manager.updateDatabase(sentence.toLowerCase());

                        PhraseExtractor extractorPhrase = PhraseExtractor.fromSentence(sentence, 1, 4);
@@ -83,7 +102,7 @@ public class Checker { 
                }

            }else if(argPars.isCheckSentence()){

                try {

                    HashTableMaker manager = new HashTableMaker();

                    HashTableMaker manager = new HashTableMaker("SQLite/hash_database_english.db");

                    manager.updateDatabase(argPars.getSentence().toLowerCase());

                    for (String phrase : PhraseExtractor.fromSentence(argPars.getSentence(),1, 4).getPhrases()) {

                        manager.updateDatabase(phrase.toLowerCase());
@@ -97,7 +116,7 @@ public class Checker { 
            SentenceExtractor extractor = SentenceExtractor.of(argPars.getFileName());

            List<String> extractedSentences = extractor.getSentences();  

            try {

                HashTableMaker manager = new HashTableMaker();

                HashTableMaker manager = new HashTableMaker("SQLite/hash_database_english.db");

                for (String sentence : extractedSentences) {

                    System.out.println("Sentence: " + sentence);
@@ -143,7 +162,7 @@ public class Checker { 
            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    new HighlighterGUI();

                    new HighlighterGUI(argPars.isDutch());

                }

            });

        }

CheckerCorrector/Corrector.java

+73 −33
Original line number Diff line number Diff line
@@ -12,11 +12,12 @@ import util.JsonMaker; 
import util.PhraseExtractor;

import util.SentenceExtractor;

import util.StringFileWriter;

import Translator.DirectTranslator;

import Translator.*;

import StateMachine.*;





public class Corrector implements GUIListener {

    ArgumentParser argParsGUI;

    SentenceExtractor extractorGUI;

    private String curSentenceGUI;

    private DBinterface dbInterfaceGUI;
@@ -26,7 +27,11 @@ public class Corrector implements GUIListener { 
    private int senteceIndGUI;

    public void start() {

        

        this.dbInterfaceGUI = new DBinterface();

        if(!this.argParsGUI.isDutch()){

            this.dbInterfaceGUI = new DBinterface("SQLite/token_database_english.db", "SQLite/smallDic.txt");

        }else{

            this.dbInterfaceGUI = new DBinterface("SQLite/token_database_dutch.db", "SQLite/DutchTranslation.txt");

        }

        this.graphGUI = new BasicGraph().getGraph();

        this.stringWriterGUI = StringFileWriter.of("corrected.txt");

        this.senteceIndGUI = 0;
@@ -79,7 +84,8 @@ public class Corrector implements GUIListener { 
        return this.curSentenceGUI;



    }

    Corrector(SentenceExtractor extractor){

    Corrector(SentenceExtractor extractor, ArgumentParser argumentParser){

        this.argParsGUI = argumentParser;

        this.extractedSentencesGUI = extractor.getSentences();

    }

    public static void main(String[] args) {
@@ -87,27 +93,36 @@ public class Corrector implements GUIListener { 
        

        ArgumentParser argPars = ArgumentParser.of(args);

        BasicGraph basicGraphClass = new BasicGraph();

        DBinterface dbInterface = new DBinterface();

        DBinterface dbInterface;

        if(!argPars.isDutch()){

            dbInterface = new DBinterface("SQLite/token_database_english.db", "SQLite/smallDic.txt");

        }else{

            dbInterface = new DBinterface("SQLite/token_database_dutch.db", "SQLite/DutchTranslation.txt");

        }

        DirectedGraph graph = basicGraphClass.getGraph();

        StringFileWriter stringWriter = StringFileWriter.of("corrected.txt");

        StringFileWriter.deleteFile("correction_details.txt");

            

        

        StringFileWriter.deleteFile("correction_details.txt");

        if(argPars.isTranslateToDutch()){

            DirectTranslatorEnglishToDutch directTranslator = DirectTranslatorEnglishToDutch.make();

            directTranslator.loadWordMapFromFile("SQLite/DutchTranslation.txt");

            if(argPars.isCheckFile()){

            if(argPars.isCorrectionGUI()){    

                    Corrector corrector = new Corrector(SentenceExtractor.of(argPars.getFileName()));

                    corrector.start();

            }else{

                SentenceExtractor extractor = SentenceExtractor.of(argPars.getFileName());

                List<String> extractedSentences = extractor.getSentences();

                for (String sentence : extractedSentences) {

                    System.out.println("Sentence: " + sentence);

                    String tempString = dbInterface.correctTokenInDatabase(sentence.toLowerCase(), graph, 2, true);

                    String tempString = directTranslator.replaceWordsInSentence(sentence.toLowerCase());

                    stringWriter.appendString(tempString);



                    

                    System.out.println("##########################################################");

                }

            }else{

                

                System.out.println("Sentence: " + argPars.getSentence());

                String tempString = directTranslator.replaceWordsInSentence(argPars.getSentence().toLowerCase());

                stringWriter.appendString(tempString);

                System.out.println("Translation: "+tempString);

                System.out.println("##########################################################");

            }

            try {

                stringWriter.writeToFile();
@@ -115,45 +130,70 @@ public class Corrector implements GUIListener { 
            } catch (IOException e) {

                System.err.println("An error occurred while writing to the file: " + e.getMessage());

            }

        }else if(argPars.isCheckSentence()){

            if(argPars.isCorrectionGUI()){  

                Corrector corrector = new Corrector(SentenceExtractor.of(argPars.getSentence()));  

                corrector.start();

        }else if(argPars.isTranslateToEnglish()){

            DirectTranslatorDutchToEnglish directTranslator = DirectTranslatorDutchToEnglish.make();

            directTranslator.loadWordMapFromFile("SQLite/DutchTranslation.txt");

            if(argPars.isCheckFile()){

                SentenceExtractor extractor = SentenceExtractor.of(argPars.getFileName());

                List<String> extractedSentences = extractor.getSentences();

                for (String sentence : extractedSentences) {

                    System.out.println("Sentence: " + sentence);

                    String tempString = directTranslator.replaceWordsInSentence(sentence.toLowerCase());

                    stringWriter.appendString(tempString);

                    System.out.println("##########################################################");

                }

            }else{

                

                System.out.println("Sentence: " + argPars.getSentence());

                stringWriter.appendString(dbInterface.correctTokenInDatabase(argPars.getSentence().toLowerCase(), graph, 2, true));

                String tempString = directTranslator.replaceWordsInSentence(argPars.getSentence().toLowerCase());

                stringWriter.appendString(tempString);

                System.out.println("Translation: "+tempString);

                System.out.println("##########################################################");

            }

            try {

                stringWriter.writeToFile();

                System.out.println("Corrected version has been written to the file.");

            } catch (IOException e) {

                System.err.println("An error occurred while writing to the file: " + e.getMessage());

            }

                System.out.println("##########################################################");

            }

        }else if(argPars.isTranslateDutch()){

            DirectTranslator directTranslator = DirectTranslator.make();

            directTranslator.loadWordMapFromFile("SQLite/word_map.txt");

            if(argPars.isCheckFile()){

        }else if(argPars.isCheckFile()){

            if(argPars.isCorrectionGUI()){    

                    

                    Corrector corrector = new Corrector(SentenceExtractor.of(argPars.getFileName()), argPars);

                    corrector.start();

            }else{

                SentenceExtractor extractor = SentenceExtractor.of(argPars.getFileName());

                List<String> extractedSentences = extractor.getSentences();

                for (String sentence : extractedSentences) {

                    System.out.println("Sentence: " + sentence);

                    String tempString = directTranslator.replaceWordsInSentence(sentence.toLowerCase());

                    String tempString = dbInterface.correctTokenInDatabase(sentence.toLowerCase(), graph, 2, true);

                    stringWriter.appendString(tempString);



                    

                    System.out.println("##########################################################");

                }

            }

            try {

                stringWriter.writeToFile();

                System.out.println("Corrected version has been written to the file.");

            } catch (IOException e) {

                System.err.println("An error occurred while writing to the file: " + e.getMessage());

            }

        }else if(argPars.isCheckSentence()){

            if(argPars.isCorrectionGUI()){  

                Corrector corrector = new Corrector(SentenceExtractor.of(argPars.getSentence()), argPars);  

                corrector.start();

            }else{

                

                System.out.println("Sentence: " + argPars.getSentence());

                stringWriter.appendString(directTranslator.replaceWordsInSentence(argPars.getSentence().toLowerCase()));

                System.out.println("##########################################################");

            }

                stringWriter.appendString(dbInterface.correctTokenInDatabase(argPars.getSentence().toLowerCase(), graph, 2, true));

                try {

                    stringWriter.writeToFile();

                    System.out.println("Corrected version has been written to the file.");

                } catch (IOException e) {

                    System.err.println("An error occurred while writing to the file: " + e.getMessage());

                }

                System.out.println("##########################################################");

            }

        }

          

    }

CheckerCorrector/DBinterface/DBinterface.java

+71 −13
Original line number Diff line number Diff line
@@ -5,6 +5,9 @@ import java.util.Arrays; 
import java.util.HashMap;

import java.util.List;

import java.io.IOException;

import java.util.Map;

import java.io.BufferedReader;

import java.io.FileReader;



import DirectedGraph.DirectedGraph;
@@ -18,15 +21,21 @@ import util.StringProcessor; 
import GUI.SelectCorrectionHandler;



public class DBinterface {

    String url;

    String dicFileName;

    public DBinterface(String url, String dicFileName){

        this.url = "jdbc:sqlite:./"+url;

        this.dicFileName = dicFileName;

    }

    public int checkTokenInDatabase(String sentence, DirectedGraph<State> graph){

        StateMachine SM = new StateMachine();

        sentence = sentence.replaceAll("\\p{Punct}", " $0");

        String[] tokens = sentence.split("\\s+");

        String url = "jdbc:sqlite:./SQLite/mydatabase.db";

        String dicFileName = "./SQLite/smallDic.txt";

        TypoCorrector typoChecker =  TypoCorrector.of(dicFileName);

        //String url = "jdbc:sqlite:./SQLite/mydatabase.db";

        //String dicFileName = "./SQLite/smallDic.txt";

        TypoCorrector typoChecker =  TypoCorrector.of(this.dicFileName);

        int initialConf = 0;

        try (Connection connection = DriverManager.getConnection(url)) {

        try (Connection connection = DriverManager.getConnection(this.url)) {



            // Lookup each token in the database and categorize it

            for (int i = 0; i < tokens.length; i++) {
@@ -112,14 +121,14 @@ public class DBinterface { 
        String[] tokens = sentence.split("\\s+");

        String[] tokensCopy = tokens.clone();

        List<String> tokenList = new ArrayList<>(Arrays.asList(tokensCopy));

        String url = "jdbc:sqlite:./SQLite/mydatabase.db";

        String dicFileName = "./SQLite/smallDic.txt";

        TypoCorrector typoChecker =  TypoCorrector.of(dicFileName);

        //String url = "jdbc:sqlite:./SQLite/mydatabase.db";

        //this.dicFileName = "./SQLite/smallDic.txt";

        TypoCorrector typoChecker =  TypoCorrector.of(this.dicFileName);

        int initialConf = 0;

        int flagsCorrectioncnt = 0;

        boolean flagTypoCorrectionAccepted = true;

        StringFileWriter sfw = StringFileWriter.of("correction_details.txt", "\n", isNotGUI);

        try (Connection connection = DriverManager.getConnection(url)) {

        try (Connection connection = DriverManager.getConnection(this.url)) {



            // Lookup each token in the database and categorize it

            for (int i = 0; i < tokens.length; i++) {
@@ -330,9 +339,9 @@ public class DBinterface { 
        List<String> tokenList = new ArrayList<>(Arrays.asList(tokensCopy));

        //String url       = "jdbc:sqlite:./SQLite/mydatabase.db";

        //String urlinsert = "jdbc:sqlite:./SQLite/newdatabase.db";

        String dicFileName = "./SQLite/smallDic.txt";

        //String dicFileName = "./SQLite/smallDic.txt";

        //String url = "jdbc:sqlite:./SQLite/newdatabase.db";

        TypoCorrector typoChecker =  TypoCorrector.of(dicFileName);

        TypoCorrector typoChecker =  TypoCorrector.of(this.dicFileName);

        int initialConf = 0;

        int cntMiss = 0;

            // Lookup each token in the database and categorize it
@@ -418,10 +427,57 @@ public class DBinterface { 


    private HashMap<String, String> wordRolesMap;



    public void updateTokenTableFromDic(String urlS, String filePath, Boolean isDutch) {

        // System.out.println("filePath");

         HashMap<String, String> wordMap = new HashMap<>();

         try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {

             

             String line;

             if(isDutch){

                while ((line = br.readLine()) != null) {

                    String[] words = line.split("\\s+");

                    if (words.length > 2) {

                        wordMap.put(words[0], words[1]);

                    }

                }

             }else{

                while ((line = br.readLine()) != null) {

                    String[] words = line.split("\\s+");

                    if (words.length > 2) {

                        if(words[2].equals("to") && words.length>3){

                            wordMap.put(words[3], words[1]);

                        }else{

                            wordMap.put(words[2], words[1]);

                        }

                    }

                }

             }

             wordRolesMap = mixHashMaps(wordMap, wordRolesMap);

             updateDatabase(urlS);

         //    System.out.println(wordMap.size());

         } catch (IOException e) {

             e.printStackTrace();

         }

     }

     public HashMap<String, String> mixHashMaps(HashMap<String, String> map1, HashMap<String, String> map2) {

        HashMap<String, String> mergedMap = new HashMap<>();

        for (Map.Entry<String, String> entry : map1.entrySet()) {

            mergedMap.put(entry.getKey(), entry.getValue());

        }

        for (Map.Entry<String, String> entry : map2.entrySet()) {

            if (mergedMap.containsKey(entry.getKey())) {

                mergedMap.put(entry.getKey(), entry.getValue());

            } else {

                mergedMap.put(entry.getKey(), entry.getValue());

            }

        }



        return mergedMap;

    }

    // Method to read data from SQLite database into HashMap

    public void readDataFromDatabase() {

        wordRolesMap = new HashMap<>();

        String dbUrl = "jdbc:sqlite:./SQLite/newdatabase.db";

        String dbUrl = this.url;//SQLite/newdatabase.db";

        try (Connection connection = DriverManager.getConnection(dbUrl)) {

            Statement statement = connection.createStatement();

            ResultSet resultSet = statement.executeQuery("SELECT * FROM word_roles");
@@ -438,8 +494,9 @@ public class DBinterface { 
    }



    // Method to update SQLite database with updated HashMap

    public void updateDatabase() {

        String dbUrl = "jdbc:sqlite:./SQLite/newdatabase.db";

    public void updateDatabase(String urlS) {

        String dbUrl = "jdbc:sqlite:./"+urlS;

        //String dbUrl = "jdbc:sqlite:./SQLite/newdatabase.db";

        try (Connection connection = DriverManager.getConnection(dbUrl)) {

            // Clear existing data in the table

            Statement clearStatement = connection.createStatement();
@@ -447,6 +504,7 @@ public class DBinterface { 


            // Insert updated data from HashMap into the table

            PreparedStatement insertStatement = connection.prepareStatement("INSERT INTO word_roles (word, role) VALUES (?, ?)");

           

            for (String word : wordRolesMap.keySet()) {

                String role = wordRolesMap.get(word);

                insertStatement.setString(1, word);

CheckerCorrector/GUI/HighlighterGUI.java

+10 −13
Original line number Diff line number Diff line
@@ -16,8 +16,9 @@ import java.util.Random; 
public class HighlighterGUI extends JFrame {

    private JTextArea textArea;

    private JButton highlightButton;



    public HighlighterGUI() {

    public boolean isDutch;

    public HighlighterGUI(boolean isDutch) {

        this.isDutch = isDutch;

        setTitle("Text Highlighter");

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new BorderLayout());
@@ -51,7 +52,7 @@ public class HighlighterGUI extends JFrame { 
    private List<String> extractPhrases(String text, int phraseLength) {

        List<String> phrases = new ArrayList<>();

        String[] words = text.split("\\s+");

        for (int i = 0; i <= words.length - phraseLength; i++) {

        for (int i = 0; i <= words.length - phraseLength; i+=phraseLength) {

            StringBuilder phraseBuilder = new StringBuilder();

            for (int j = 0; j < phraseLength; j++) {

                phraseBuilder.append(words[i + j]);
@@ -65,7 +66,12 @@ public class HighlighterGUI extends JFrame { 
    }



    private void highlightPhrases(List<String> phrases) {

        DBinterface dbInterface = new DBinterface();

        DBinterface dbInterface;

        if(!this.isDutch){

            dbInterface = new DBinterface("SQLite/token_database_english.db", "SQLite/smallDic.txt");

        }else{

            dbInterface = new DBinterface("SQLite/token_database_dutch.db", "SQLite/DutchTranslation.txt");

        }

        BasicGraph basicGraphClass = new BasicGraph();

        for (String phrase : phrases) {

            highlightPhrase(phrase, dbInterface.checkTokenInDatabase(phrase, basicGraphClass.getGraph()));
@@ -90,13 +96,4 @@ public class HighlighterGUI extends JFrame { 
            index = text.indexOf(phrase, index + 1);

        }

    }



    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            @Override

            public void run() {

                new HighlighterGUI();

            }

        });

    }

}

CheckerCorrector/HashTableMaker/HashTableMaker.java

+2 −2
Original line number Diff line number Diff line
@@ -11,8 +11,8 @@ import util.PhraseExtractor; 
public class HashTableMaker {

    private Connection connection;



    public HashTableMaker() throws SQLException {

        connection = DriverManager.getConnection("jdbc:sqlite:SQLite/hash_database.db");

    public HashTableMaker(String dbName) throws SQLException {

        connection = DriverManager.getConnection("jdbc:sqlite:SQLite/hash_database.db"+dbName);

        createTableIfNotExists();

    }