Initial commit

.gitignore

@@ -0,0 +1,23 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# PyBuilder
+target/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+.idea
+*_venv/
+data/
+output*/
+
+*.zip

Database.py

@@ -0,0 +1,44 @@
+from dotenv import dotenv_values
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+
+class Database:
+
+    def __init__(self, collection_name) -> None:
+        env_values = dotenv_values(".env")
+        self.url = env_values['MONGO_CLIENT']
+        self.db_name = env_values['DB_NAME']
+        self.collection_name = collection_name
+        self.__connect_db()
+
+    def __connect_db(self):
+        client = MongoClient(self.url)
+        self.db = client[self.db_name]
+
+    def __fetch_collection(self, collection_name: str):
+        collection = self.db.get_collection(collection_name)
+        return collection
+
+    def insert_docs(self,doc_list):
+        collection = self.__fetch_collection(self.collection_name)
+        collection.insert_many(doc_list)
+
+    def find_docs(self, query,projection={}):
+        collection = self.__fetch_collection(self.collection_name)
+        return collection.find(query,projection)
+
+    def estimated_doc_count(self):
+        collection = self.__fetch_collection(self.collection_name)
+        return collection.estimated_document_count()
+        
+    def update_by_id(self, doc_id, col_name: str, col_val):
+        collection = self.__fetch_collection(self.collection_name)
+        collection.update_one(
+            {"_id": ObjectId(doc_id)},
+            {"$set": {col_name: col_val}}
+        )
+    
+    def update_by_field(self, match, replacement):
+        collection = self.__fetch_collection(self.collection_name)
+        # collection.update_one(match,{"$set":replacement})
+        collection.update_many(match,{"$set":replacement})

README.md

@@ -1,13 +1,43 @@
----
-title: JRefactoring
-emoji: 📉
-colorFrom: red
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.17.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# jRefactoring 
+
+
+# Project Overview
+
+
+
+## Dependencies
+
+- keras==2.12.0
+- matplotlib==3.7.1
+- numpy==1.23.5
+- pandas==1.5.3
+- PyDriller==2.4.1
+- pymongo==4.3.3
+- python-dotenv==1.0.0
+- scikit_learn==1.2.2
+- torch==2.0.0
+- transformers==4.27.2
+
+## Dataset
+
+The dataset used in this project is collected from SEART tool. The parameters used in this tool are as follows:
+
+![Example image](helpers/SEART.png)
+
+It resulted in 146 projects. These projects served as our dataset.
+
+## Models
+
+## Results
+
+## Instructions for Replication
+
+## Code Structure
+
+## Acknowledgments
+
+## Contact Information
+
+
+
+

app.py

@@ -0,0 +1,18 @@
+
+from flask import Flask, request, render_template
+from predict import Predict
+
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    feature_list = request.form.to_dict()
+    result = Predict().predict(feature_list['code'])
+    return render_template('index.html', prediction_text=result)
+
+if __name__ == "__main__":
+    app.run(debug=True, use_reloader=False, port='8080')

archive/codeBert.py

@@ -0,0 +1,15 @@
+from refactor_analysis import RefactorAnalysis
+from transformers import AutoTokenizer, AutoModel
+import torch
+model_name = "huggingface/CodeBERTa-small-v1"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModel.from_pretrained(model_name)
+tokenized_inputs =[tokenizer(file_content, return_tensors="pt") for file_content in RefactorAnalysis()._parent_child_commit_map()]
+
+
+with torch.no_grad():
+    outputs = [model(**input) for input in tokenized_inputs]
+    embeddings = [output.last_hidden_state.mean(dim=1).squeeze() for output in outputs]
+# print(RefactorAnalysis()._parent_child_commit_map())
+
+print(embeddings[0].shape)

autoencoder.py

@@ -0,0 +1,164 @@
+from keras.layers import Input, Dense, Flatten
+from keras.models import Model
+from Database import Database
+import numpy as np, json
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+from dotenv import dotenv_values
+import pandas as pd
+# from tensorflow.python.ops.confusion_matrix import confusion_matrix
+from sklearn.metrics import precision_recall_fscore_support
+
+class Autoencoder:
+
+    def __get_autoencoder(self, input_dim) -> Model:
+        input_shape = (input_dim,)
+        input_layer = Input(shape=input_shape)
+
+        # Encoder layers
+        encoder = Flatten()(input_layer)
+        encoder = Dense(128, activation='relu')(encoder)
+        encoder = Dense(64, activation='relu')(encoder)
+        # encoder = Dense(32, activation='relu')(encoder)
+
+        # Decoder layers
+        # decoder = Dense(64, activation='relu')(encoder)
+        decoder = Dense(128, activation='relu')(encoder)  #decoder
+        decoder = Dense(input_dim, activation='sigmoid')(decoder)
+
+        # Autoencoder model
+        autoencoder = Model(inputs=input_layer, outputs=decoder)
+        # autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
+        autoencoder.compile(optimizer='adam', loss='mse')
+
+        return autoencoder
+    
+    def __print_summary(self, model: Model):
+        print(model.summary())
+        return
+    
+    def __fit_autoencoder(self,epochs,batch_size,model: Model, train_var,valid_var=None):
+        history =  model.fit(train_var,train_var,
+                        #  validation_data=(valid_var,valid_var),
+                         epochs=epochs,batch_size=batch_size)
+        return history, model
+
+    def __split_train_test_val(self, data):
+        train_array, test_array = train_test_split(data,test_size=0.2,random_state=42)
+        train_array, valid_array = train_test_split(train_array,test_size=0.1,random_state=42)
+        return train_array, valid_array, test_array
+    
+    @staticmethod
+    def __compute_metrics(conf_matrix):
+        precision = conf_matrix[1][1] / (conf_matrix[1][1] + conf_matrix[0][1])
+
+        if precision==1:
+            print(conf_matrix)
+
+        recall = conf_matrix[1][1] / (conf_matrix[1][1] + conf_matrix[1][0])
+        f1 = (2 * precision * recall) / (precision + recall)
+        # print("precision: " + str(precision) + ", recall: " + str(recall) + ", f1: " + str(f1))
+        return precision, recall, f1
+
+    def __find_optimal_modified(self,error_df: pd.DataFrame, steps=50):
+        min_error, max_error = error_df["Reconstruction_error"].min(), error_df["Reconstruction_error"].max()
+        optimal_threshold = (min_error+max_error)/2
+        y_pred = [0 if e > optimal_threshold else 1 for e in error_df.Reconstruction_error.values]
+        precision, recall, f1,_=precision_recall_fscore_support(error_df.True_class, y_pred, average='macro')
+
+        return optimal_threshold, precision, recall, f1
+
+    def __find_optimal(self,error_df: pd.DataFrame, steps=50):
+        min_error, max_error = error_df["Reconstruction_error"].min(), error_df["Reconstruction_error"].max()
+        optimal_threshold = min_error
+        max_f1 = 0
+        max_pr = 0
+        max_re = 0
+        # step_value = (max_error-min_error)/(steps - 1)
+        for threshold in np.arange(min_error, max_error, 0.005):
+            # print("Threshold: " + str(threshold))
+            # y_pred = [1 if e > threshold else 0 for e in error_df.Reconstruction_error.values]
+            y_pred = [0 if e > threshold else 1 for e in error_df.Reconstruction_error.values]
+            # conf_matrix = confusion_matrix(error_df.True_class, y_pred)
+            # precision, recall, f1 = self.__compute_metrics(conf_matrix)
+            # precision, recall, f1,_=precision_recall_fscore_support(error_df.True_class, y_pred, average='macro')
+            # precision, recall, f1,_=precision_recall_fscore_support(error_df.True_class, y_pred, average='micro')
+            # precision, recall, f1,_=precision_recall_fscore_support(error_df.True_class, y_pred, average='weighted')
+            precision, recall, f1,_=precision_recall_fscore_support(error_df.True_class, y_pred, average='binary')
+
+            if f1 > max_f1:
+                max_f1 = f1
+                optimal_threshold = threshold
+                max_pr = precision
+                max_re = recall
+        print(f"Result optimal_threshold={optimal_threshold}, max_precision={max_pr}, max_recall={max_re}, max_f1={max_f1}")
+        # return optimal_threshold, max_pr.numpy(), max_re.numpy(), max_f1.numpy()
+        return optimal_threshold, max_pr, max_re, max_f1
+
+    @staticmethod
+    def __split_by_percent(data,percent):
+        return train_test_split(data,test_size=0.3,random_state=42)
+
+
+
+    def train_autoencoder(self):
+        #GraphCodeBERT
+
+        autoencoder = self.__get_autoencoder(768)
+        self.__print_summary(autoencoder)
+
+        #Create Dataset df
+        df = pd.DataFrame(columns=['Embedding','True_class'])
+
+
+        #DB
+        db = Database(dotenv_values(".env")['COLLECTION_NAME'])
+        # embeddings_list = [emb["embedding"] for emb in list(db.find_docs({"refactoring_type":"Extract Method"}))]
+        pos_emb_list, neg_emb_list = [],[] 
+        for doc in list(db.find_docs({"refactoring_type":"Extract Method"})):
+            pos_emb_list.append(doc['embedding_pos'])
+            neg_emb_list.append(doc['embedding_neg'])
+        
+        pos_emb_list_train, pos_emb_list_test = self.__split_by_percent(pos_emb_list,0.3)
+        _, neg_emb_list_test = self.__split_by_percent(neg_emb_list,0.3)
+
+        x_train = np.array(pos_emb_list_train)
+        x_test = np.array(pos_emb_list_test+neg_emb_list_test)
+        y_test = np.array([1 for i in range(0,len(pos_emb_list_test))]+[0 for i in range(0,len(neg_emb_list_test))])
+        # print(np.array(pos_emb_list_train).shape)
+
+        epoch = 25
+        history, trained_model = self.__fit_autoencoder(epoch,32,autoencoder,x_train)
+        trained_model.save('./results/autoencoder_'+str(epoch)+'.hdf5')
+
+        #Test
+        test_predict = trained_model.predict(x_test)
+
+        mse = np.mean(np.power(x_test - test_predict, 2), axis=1)
+
+        
+        error_df = pd.DataFrame({'Reconstruction_error': mse,
+                        'True_class': y_test})
+
+        print("Max: ", error_df["Reconstruction_error"].max())
+        print("Min: ", error_df["Reconstruction_error"].min())
+
+        # optimal_threshold, precision, recall, f1 = self.__find_optimal(error_df,100)
+        optimal_threshold, precision, recall, f1 = self.__find_optimal_modified(error_df,100)
+        print(f"Result optimal_threshold={optimal_threshold}, max_precision={precision}, max_recall={recall}, max_f1={f1}")
+        metrics = {
+            "Threshold":optimal_threshold,
+            "Precision": precision,
+            "Recall":recall,
+            "F1":f1
+        }
+        with open('./results/metrics.json','w') as fp:
+            json.dump(metrics,fp)
+
+        plt.plot(history.history['loss'])
+
+        plt.savefig("./results/training_graph.png")
+
+if __name__=="__main__":
+    Autoencoder().train_autoencoder()

graphCodeBert.py

@@ -0,0 +1,56 @@
+from transformers import  AutoTokenizer, AutoModel
+
+from Database import Database
+
+class GraphCodeBert:
+
+    def __init__(self) -> None:
+        model_name = "microsoft/graphcodebert-base"
+        self.tokenizer= AutoTokenizer.from_pretrained(model_name)
+        self.model=AutoModel.from_pretrained(model_name)
+
+
+    def generate_embeddings(self):
+        database = Database("refactoring_details_neg")
+        # database.connect_db()
+        # collection = database.fetch_collection("refactoring_information")
+        # collection_len = collection.estimated_document_count()
+        collection_len = database.estimated_doc_count()
+
+
+        doc_count = 1
+        for doc in database.find_docs({}, {"_id": 1, "method_refactored": 1, "meth_rf_neg":1}):
+            doc_id = doc["_id"]
+            code_snippet = doc["method_refactored"]
+            code_snippet_neg = doc["meth_rf_neg"]
+            print(f'Generating embedding for doc_id:{doc_id} | Count-{doc_count}...')
+            
+            # Compute embeddings
+            tokenized_input_pos = self.tokenizer(code_snippet, return_tensors="pt", padding=True, truncation=True)
+            output = self.model(**tokenized_input_pos)
+            embedding_pos = output.last_hidden_state.mean(dim=1).squeeze().tolist()
+
+            #Neg Embedding
+            tokenized_input_neg = self.tokenizer(code_snippet_neg, return_tensors="pt", padding=True, truncation=True)
+            output = self.model(**tokenized_input_neg)
+            embedding_neg = output.last_hidden_state.mean(dim=1).squeeze().tolist()
+
+            # Update document in MongoDB with embedding
+            database.update_by_id(doc_id, "embedding_pos", embedding_pos)
+            database.update_by_id(doc_id,"embedding_neg", embedding_neg)
+
+            collection_len -= 1
+            doc_count += 1
+            print(f'Embedding added for doc_id:{doc_id} | Remaining: {collection_len}.')
+
+    def generate_individual_embedding(self,code_snippet):
+        tokenized_input_pos = self.tokenizer(code_snippet, return_tensors="pt", padding=True, truncation=True)
+        output = self.model(**tokenized_input_pos)
+        embedding = output.last_hidden_state.mean(dim=1).squeeze().tolist()
+
+        return embedding
+
+
+
+if __name__=="__main__":
+    GraphCodeBert().generate_embeddings()

mongodb-playground/queries.mongodb

@@ -0,0 +1,4 @@
+use('jrefactoring');
+
+db.refactoring_information.count({})
+// db.refactoring_information.drop()

predict.py

@@ -0,0 +1,45 @@
+from graphCodeBert import GraphCodeBert
+from keras.models import load_model, Model
+import numpy as np, json
+
+class Predict:
+
+    def __generate_code_embedding(self,code_snippet):
+        embedding = np.array(GraphCodeBert().generate_individual_embedding(code_snippet)).reshape((1,768))
+        return embedding
+    def __calculate_loss(self,code_embedding,model_name):
+        model:Model = load_model(f'results/{model_name}.hdf5')
+        return model.evaluate(code_embedding,code_embedding)
+
+
+    def predict(self,code_snippet):
+        model_name="autoencoder_25"
+
+        code_embedding = self.__generate_code_embedding(code_snippet)
+        print("Input code snippet shape: ",code_embedding.shape)
+        loss = self.__calculate_loss(code_embedding,model_name)
+        print("Reconstruction Loss: ",loss)
+
+        with open('./results/metrics.json',"r") as fp:
+            metric_json = json.loads(fp.read())
+        
+        threshold = metric_json["Threshold"]
+
+        return "Not a candidate for refactoring" if loss>threshold else "Is a candidate for refactoring"
+
+
+
+
+if __name__=="__main__":
+    Predict().predict("""	public void sleep(){
+		int s1 = 1;
+		int s2 = 2;
+		int s3 = 3;
+		int s4 = 4;
+		int s5 = 5;
+		int s6 = 6;
+		int s7 = 7;
+		int s8 = 8;
+
+	}""")
+

refactor_analysis.py

@@ -0,0 +1,142 @@
+import os, subprocess, pydriller,json, pandas as pd
+import sys
+from dotenv import dotenv_values
+
+from Database import Database
+
+class RefactorAnalysis:
+
+    def __init__(self,input_path="",output_path=""):
+        if input_path=="":
+            self.input_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),"data","refactoring-toy-example")
+        else:
+            self.input_path=input_path
+        if output_path=="":
+            self.output_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),"output_ref","output.json")
+        else:
+            self.output_path=output_path
+
+    
+    def generate_refactor_details(self):
+        # ref_miner_bin = os.path.join(os.path.dirname(os.path.abspath(__file__)),"executable","RefactoringMiner","bin")
+        ref_miner_bin = os.path.abspath("executable/RefactoringMiner/bin")
+        # command = ["cd",ref_miner_bin,"&&","sh","RefactoringMiner","-a",self.input_path,"-json",self.output_path]
+        command = ["sh","RefactoringMiner","-a",self.input_path,"-json",self.output_path]
+        try:
+            os.chdir(ref_miner_bin)
+            shell_result = subprocess.run(command,capture_output=True,text=True)
+            shell_result.check_returncode()
+            # if shell_result!=0:
+            #     raise Exception("Couldn't analyze repository - "+self.input_path+" with RefactorMiner")
+            # return 0
+        except subprocess.CalledProcessError as error:
+            print(error)
+            sys.exit()
+
+        except Exception as e:
+            print(e)
+            return 1
+
+    def parse_json_output(self):
+        #TODO
+        #Filter for Method Refs
+        with open(self.output_path) as f:
+            json_output = json.load(f)
+            
+
+        dict_output = {}
+        for obj in json_output["commits"]:
+            if len(obj["refactorings"])==0:
+                continue
+            changes = []
+            se_lines = []
+            for ref in obj["refactorings"]:
+                if not "Method" in ref["type"]:
+                    continue
+                for parent_refs in ref["leftSideLocations"]:
+
+                    changes.append(parent_refs["filePath"])
+                    se_lines.append((parent_refs["startLine"],parent_refs["endLine"]))
+            # list_output.append(dict_output)
+            dict_output[obj["sha1"]]={
+                "paths":changes,
+                "ref_start_end":se_lines,
+                "ref_type":ref["type"]
+            }
+
+        return dict_output
+ 
+    def create_project_dataframe(self):
+
+        df = pd.DataFrame(columns=['commit','refactoring_type','filename','meth_rf_neg','method_refactored'])
+
+        parse_output_dict = self.parse_json_output()
+        commits_to_analyze = list(parse_output_dict.keys())
+        for commit in pydriller.Repository(self.input_path, only_commits=commits_to_analyze).traverse_commits():
+            ref_list = parse_output_dict.get(commit.hash)
+            ref_path_name = list(map(lambda x: str(x).split("/")[len(str(x).split("/"))-1],ref_list["paths"]))
+            for cf in commit.modified_files:
+                try:
+                    index_ref = ref_path_name.index(cf.filename)
+                except ValueError as ve:
+                    continue
+                if len(cf.changed_methods)==0:
+                    continue
+                #Diff between methods_changed and methods_before - does methods_changed reduces loop else we have to loop for all methods  
+                for cm in cf.changed_methods:
+                    
+                    if cm.start_line<=ref_list["ref_start_end"][index_ref][0] and cm.end_line>=ref_list["ref_start_end"][index_ref][1]:
+                        method_source_code = self.__split_and_extract_methods(cf.source_code_before,cm.start_line,cm.end_line)
+                        method_source_code_neg = self.__split_and_extract_methods(cf.source_code,cm.start_line,cm.end_line)
+                        class_source_code = cf.source_code_before
+
+                        # df_row = {"commit":commit.hash,"refactoring_type":ref_list["ref_type"],"filename":cf.filename, "meth_rf_neg":class_source_code,"method_refactored":method_source_code}
+                        df_row = {"commit":commit.hash,"refactoring_type":ref_list["ref_type"],"filename":cf.filename, "meth_rf_neg":method_source_code_neg,"method_refactored":method_source_code}
+                        df.loc[len(df)] = df_row
+        return df
+
+
+    def __split_and_extract_methods(self, source_code,start_line, end_line):
+        source_code_lines = str(source_code).splitlines()
+        return "\n".join(source_code_lines[start_line-1:end_line])
+
+def main():
+    if not os.path.exists("data/repos/"):
+        try:
+            print("Starting repo download")
+            repo_script = subprocess.run(["python","repo_download.py"], capture_output=True, text=True)
+            repo_script.check_returncode()
+        except subprocess.CalledProcessError as err:
+            print(err)
+            sys.exit(1)
+    print("Repo Download Completed")
+    lst_repos = next(os.walk("data/repos/"))[1]
+    print(len(lst_repos))
+
+    cwd = os.path.dirname(os.path.abspath(__file__))
+    final_df = pd.DataFrame(columns=['commit','refactoring_type','filename','meth_rf_neg','method_refactored'])
+    database = Database(dotenv_values(".env")['COLLECTION_NAME'])
+    # database.connect_db()
+    count=1
+    batch_size = 5
+    for idx,repo in enumerate(lst_repos):
+        os.chdir(cwd)
+        try:
+            ref_obj = RefactorAnalysis(os.path.abspath(os.path.join("data/repos",repo)),os.path.abspath(os.path.join("output_ref",repo+".json")))
+            # ref_miner = ref_obj.generate_refactor_details()               #Modify
+            df = ref_obj.create_project_dataframe()
+        except Exception as e:
+            print(e)
+            continue
+        
+        final_df = pd.concat([final_df,df], ignore_index=True)
+        if count==batch_size or idx==len(lst_repos)-1:
+            print("Inserting into DB", idx)
+            database.insert_docs(final_df.to_dict(orient="records"))              
+            final_df = pd.DataFrame(columns=['commit','refactoring_type','filename','meth_rf_neg','method_refactored'])
+            count=1
+        else:
+            count+=1
+
+if __name__=="__main__":
+    main()

repo_download.py

@@ -0,0 +1,33 @@
+import os, subprocess, csv
+
+def download_repo(repo_name, repos_base_path):
+    repo_fullname = repo_name.strip('\n')
+    if not repo_fullname == "":
+        project_url = "https://github.com/" + repo_fullname + ".git"
+        folder_name = repo_fullname.replace("/", "_")
+        folder_path_new = os.path.join(repos_base_path, folder_name)
+
+        if not os.path.exists(folder_path_new):
+            _download_with_url(project_url, folder_path_new)
+        else:
+            print(folder_name + " already exists. skipping ...")
+
+def _download_with_url(project_url, folder_path):
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+    print("cloning... " + project_url)
+    try:
+        # depth=1 is only to get the current snapshot (rather than all commits)
+        subprocess.call(["git", "clone", project_url, folder_path])
+    except Exception as ex:
+        print("Exception occurred!!" + str(ex))
+        return
+    print("cloning done.")
+
+if __name__=='__main__':
+    print("Starting repo download")
+    with open("data/repos.csv") as repo_file:
+        reader = csv.reader(repo_file, delimiter=',')
+        next(reader)
+        for line in reader:
+            download_repo(line[0], 'data/repos')

requirements.txt

@@ -0,0 +1,11 @@
+Flask==2.2.3
+keras==2.12.0
+matplotlib==3.7.1
+numpy==1.23.5
+pandas==1.5.3
+PyDriller==2.4.1
+pymongo==4.3.3
+python-dotenv==1.0.0
+scikit_learn==1.2.2
+torch==2.0.0
+transformers==4.27.2

results/metrics.json

@@ -0,0 +1 @@
+{"Threshold": 0.11413681637927062, "Precision": 0.7785714285714286, "Recall": 0.6025641025641025, "F1": 0.5280109310950615}

templates/css/main.css

@@ -0,0 +1,76 @@
+body {
+    margin: 0;
+    padding: 0;
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    color: #444;
+  }
+  /*
+   * Formatting the header area
+   */
+  header {
+    background-color: #DFB887;
+    height: 35px;
+    width: 100%;
+    opacity: .9;
+    margin-bottom: 10px;
+  }
+  header h1.logo {
+    margin: 0;
+    font-size: 1.7em;
+    color: #fff;
+    text-transform: uppercase;
+    float: left;
+  }
+  header h1.logo:hover {
+    color: #fff;
+    text-decoration: none;
+  }
+  /*
+   * Centering the body content
+   */
+  .container {
+    width: 1200px;
+    margin: 0 auto;
+  }
+  div.home {
+    padding: 10px 0 30px 0;
+    background-color: #E6E6FA;
+    -webkit-border-radius: 6px;
+       -moz-border-radius: 6px;
+            border-radius: 6px;
+  }
+  div.about {
+    padding: 10px 0 30px 0;
+    background-color: #E6E6FA;
+    -webkit-border-radius: 6px;
+       -moz-border-radius: 6px;
+            border-radius: 6px;
+  }
+  h2 {
+    font-size: 3em;
+    margin-top: 40px;
+    text-align: center;
+    letter-spacing: -2px;
+  }
+  h3 {
+    font-size: 1.7em;
+    font-weight: 100;
+    margin-top: 30px;
+    text-align: center;
+    letter-spacing: -1px;
+    color: #999;
+  }
+  .menu {
+    float: right;
+    margin-top: 8px;
+  }
+  .menu li {
+    display: inline;
+  }
+  .menu li + li {
+    margin-left: 35px;
+  }
+  .menu li a {
+    color: #444;
+    text-decoration: none;
+  }

templates/index.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html >
+<head>
+    <meta charset="UTF-8">
+    <title>jRefactoring</title>
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
+	<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
+	<script src="https://cdn.jsdelivr.net/npm/popper.js@1.14.7/dist/umd/popper.min.js" integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous"></script>
+	<script src="https://cdn.jsdelivr.net/npm/bootstrap@4.3.1/dist/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"></script>
+	<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.3.1/dist/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
+</head>
+
+<body>
+	<div class="container">
+		<div class="prediction">
+			<h1><a href="https://git.cs.dal.ca/gshetty/jrefactoring.git">jRefactoring</a></h1>
+			<form action="{{ url_for('predict')}}"method="post">
+			<p>Source Code:</p>
+			<p>Enter your code snippet (Java)</p>
+			<code><textarea type="textbox" id="code" name="code" required="required" rows="10" cols="100" autofocus autocomplete="off"></textarea></code><br>
+			<button type="submit" class="btn btn-primary btn-large">Predict</button>
+			</form>
+		<br>
+		<b>{{ prediction_text }}</b>
+		</div>
+	</div>
+</body>
+</html>