├── README.md
├── dataset
    ├── AspectJ.txt
    ├── Eclipse_Platform_UI.txt
    ├── JDT.txt
    ├── SWT.txt
    └── Tomcat.txt
└── src
    ├── com
        └── cityu
        │   └── xy
        │       ├── BR_BugItemGenerator.java
        │       ├── BugItem.java
        │       ├── BugReportMain.java
        │       ├── FileUtils.java
        │       ├── JdtAstUtil.java
        │       ├── LogUtils.java
        │       ├── SourceCodeManager.java
        │       └── SourceFile.java
    └── libs
        └── org.eclipse.jgit-4.6.1.201703071140-r.jar


/README.md:
--------------------------------------------------------------------------------
 1 | This code belongs to Improving Bug Localization with an Enhanced Convolutional Neural Network (APSEC 2017) and Improving Bug Localization with Word Embedding and Enhanced Convolutional Neural Networks (IST).
 2 | 
 3 | This code is used to collect data from github based on the mappings between bug reports and corresponding buggy files provided in Learning to Rank Relevant Files for Bug Reports using Domain Knowledge. Thanks to the authors. 
 4 | 
 5 | Requirements: Java with the packages in the libs of src and the following packages are used to extract ast:  
 6 |        org.eclipse.core.contenttype.jar
 7 |        org.eclipse.core.jobs.jar
 8 |        org.eclipse.core.resources.jar
 9 |        org.eclipse.core.runtime.jar
10 |        org.eclipse.equinox.common.jar
11 |        org.eclipse.equinox.preferences.jar
12 |        org.eclipse.jdt.core.jar
13 |        org.eclipse.osgi.jar
14 | 
15 | BugReportMain.java is the main function.
16 | 
17 | The source code with different versions of five projects used in our paper can be found here: https://www.dropbox.com/sh/143peoq6277hz2u/AAA4ocW_AC7fKF04KB6Hxe94a?dl=0
18 | or http://pan.baidu.com/s/1slK2vRv
19 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/BR_BugItemGenerator.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | 
 3 | import java.io.BufferedReader;
 4 | import java.io.File;
 5 | import java.io.FileReader;
 6 | import java.io.IOException;
 7 | import java.util.ArrayList;
 8 | import java.util.List;
 9 | 
10 | /**
11 |  * 
12 |  * @author xiaoyan
13 |  *
14 |  */
15 | public class BR_BugItemGenerator {
16 | 	public final String TAG = BR_BugItemGenerator.class.getSimpleName();
17 | //	public final String BUG_REPORT_FILE = "dataset/SWT.txt";
18 | //	public final String BUG_REPORT_FILE = "dataset/JDT.txt";
19 | //	public final String BUG_REPORT_FILE = "dataset/AspectJ.txt";
20 | //	public final String BUG_REPORT_FILE = "dataset/Eclipse_Platform_UI.txt";
21 | 	public final String BUG_REPORT_FILE = "dataset/Tomcat.txt";
22 | 
23 | 
24 | 
25 | 	public SourceCodeManager sourceCodeManager;
26 | 
27 | 	public BR_BugItemGenerator() {
28 | 		sourceCodeManager = SourceCodeManager.getInstance();
29 | 	}
30 | 
31 | 	/**
32 | 	 * 
33 | 	 * @param file bugReport file
34 | 	 * @return  bugItem list
35 | 	 */
36 | 	public List<BugItem> generateBugItemsFromFile(String file) {
37 | 		if (file == null || file.length() < 0) {
38 | 			return null;
39 | 		}
40 | 
41 | 		List<BugItem> items = new ArrayList<BugItem>();
42 | 
43 | 		BufferedReader br = null;
44 | 		try {
45 | 			LogUtils.log(TAG, "try to open bugReport file: " + file);
46 | 			br = new BufferedReader(new FileReader(new File(file)));
47 | 			LogUtils.log(TAG, "open bugReport file successfully!");
48 | 
49 | 			LogUtils.log(TAG, "Parsing bugReport file...");
50 | 			String line = null;
51 | 			while ((line = br.readLine()) != null) {
52 | 				// skip headline
53 | 				char firstChar = line.charAt(0);
54 | 				if (firstChar > '9' || firstChar < '0') {
55 | 					LogUtils.log(TAG, "Skip line: " + line);
56 | 					continue;
57 | 				}
58 | 
59 | 				items.add(new BugItem(line));
60 | 			}
61 | 			LogUtils.log(TAG, "parsing bugReport file finished!");
62 | 		} catch (IOException e) {
63 | 			e.printStackTrace();
64 | 		} catch (Exception e) {
65 | 			e.printStackTrace();
66 | 		} finally {
67 | 			try {
68 | 				if (br != null) {
69 | 					br.close();
70 | 				}
71 | 			} catch (IOException e) {
72 | 				e.printStackTrace();
73 | 			}
74 | 		}
75 | 
76 | 		return items;
77 | 	}
78 | 
79 | 	/**
80 | 	 * generate bugItem label, this function must be invoke after {@link #sourceCodeManager.initSourFileContext}
81 | 	 * @param items
82 | 	 */
83 | 	public void generateFileLabel(List<BugItem> items) {
84 | 		LogUtils.log(TAG, "start generate BugItem label...");
85 | 		for (BugItem bugItem : items) {
86 | 			List<String> files = bugItem.files;
87 | 			if (files != null && files.size() > 0) {
88 | 				bugItem.bugFileLable = sourceCodeManager.getBugReportLabel(files);
89 | 			}
90 | 		}
91 | 		LogUtils.log(TAG, "generating label finished!");
92 | 	}
93 | }
94 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/BugItem.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | public class BugItem {
 7 | 	// private final String TAG = BugItem.class.getSimpleName();
 8 | 
 9 | 	public int id;
10 | 	public int bugId;
11 | 	public String summary;
12 | 	public String description;
13 | 	public String reportTime;
14 | 	public String reportTimes;
15 | 	public String status;
16 | 	public String commit;
17 | 	public String commintTime;
18 | 	public List<String> files;
19 | 
20 | 	public String bugFileLable;
21 | 
22 | 	private final int ITEM_SIZE = 10; // the number of contents that BugItem contains, e.g., ID,bugId
23 | 
24 | 	public BugItem(String itemStr) {
25 | 		if (itemStr == null || itemStr.length() <= 0) {
26 | 			return;
27 | 		}
28 | 
29 | 		String[] contents = itemStr.split("\t");
30 | 		if (contents.length < ITEM_SIZE) {
31 | 			// when the number of contents that BugItem contains isn't correct, stop running. This is used to check errors.
32 | 			throw new IllegalArgumentException();
33 | 		}
34 | 
35 | 		int index = 0;
36 | 		this.id = Integer.valueOf(contents[index++]);
37 | 
38 | 		this.bugId = Integer.valueOf(contents[index++]);
39 | 		this.summary = contents[index++];
40 | 		this.description = contents[index++];
41 | 		this.reportTime = contents[index++];
42 | 		this.reportTimes = contents[index++];
43 | 		this.status = contents[index++];
44 | 		this.commit = contents[index++];
45 | 		this.commintTime = contents[index++];
46 | 
47 | 		files = new ArrayList<String>();
48 | 		String[] files = contents[index++].split(".java ");
49 | 		for (String file : files) {
50 | 			if (!file.endsWith(".java")) {
51 | 				this.files.add(file + ".java");
52 | 			}else{
53 | 				this.files.add(file);
54 | 			}
55 | 		}
56 | 	}
57 | 
58 | 	public String getBugFileLable() {
59 | 		return bugFileLable;
60 | 	}
61 | 
62 | 	public void setBugFileLable(String bugFileMap) {
63 | 		this.bugFileLable = bugFileMap;
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/BugReportMain.java:
--------------------------------------------------------------------------------
  1 | package com.cityu.xy;
  2 | 
  3 | import java.io.BufferedWriter;
  4 | import java.io.File;
  5 | import java.io.FileWriter;
  6 | import java.io.IOException;
  7 | import java.util.ArrayList;
  8 | import java.util.List;
  9 | 
 10 | public class BugReportMain {
 11 | 	private final static String TAG = BugReportAstMain.class.getSimpleName();
 12 | 
 13 | 	public static void main(String[] args) throws Exception {
 14 | 		// open log
 15 | 		LogUtils.setOpen(true);
 16 | 
 17 | 		BufferedWriter bw = null;
 18 | 
 19 | 		// generate BugItem
 20 | 		LogUtils.log(TAG, "generate bugItem ...");
 21 | 		BR_BugItemGenerator generator = new BR_BugItemGenerator();
 22 | 		List<BugItem> items = generator.generateBugItemsFromFile(generator.BUG_REPORT_FILE);
 23 | 
 24 | 		SourceCodeManager sourceCodeManager = SourceCodeManager.getInstance();
 25 | 		sourceCodeManager.initSourFileContext(items);
 26 | 
 27 | 		// if the source code of different versions need to be pulled from github, open this switch
 28 | 		 if (SourceCodeManager.GIT_CHECKOUT) {
 29 | 			 sourceCodeManager.gitAllSourceCodeFile(items);
 30 | 			 return;
 31 | 		 }
 32 | 
 33 | 		ArrayList<String> bugFiles = new ArrayList<String>();
 34 | 		for (BugItem item : items) {
 35 | 			List<String> files = sourceCodeManager.getLocalSourceFile(item);
 36 | 
 37 | 			if (files == null) {
 38 | 				continue;
 39 | 			}
 40 | 
 41 | 			for (String filePath : files) {
 42 | 				File file = new File(filePath);
 43 | 				if (!file.exists()) {
 44 | 					LogUtils.log(TAG, item.id + " " + item.commit + " " + file.getAbsolutePath());
 45 | 				} else {
 46 | 					if(!bugFiles.contains(file.getAbsolutePath())){
 47 | 						bugFiles.add(file.getAbsolutePath());
 48 | 					}
 49 | 				}
 50 | 			}
 51 | 		}
 52 | 
 53 | 		sourceCodeManager.setSourceFiles(bugFiles);
 54 | 		// sourceCodeManager.initAllSourceFile();
 55 | 
 56 | 		// according sourceManager to generate bugLabel
 57 | 		generator.generateFileLabel(items);
 58 | 
 59 | 		// write bugItem into text files
 60 | 		try {
 61 | 			bw = new BufferedWriter(new FileWriter(new File(SourceCodeManager.LOCAL_FILE_PREFIX + "bugItem.txt")));
 62 | 
 63 | 			LogUtils.log(TAG, "write bugItem into txt files");
 64 | 			for (BugItem item : items) {
 65 | 				if (item != null && item.bugFileLable != null && item.bugFileLable.length() > 0) {
 66 | 					if (item.description != null && item.description.length() > 0) {
 67 | 						bw.write(item.description);
 68 | 					} 
 69 | 					
 70 | 					if(item.summary != null && item.summary.length() > 0){
 71 | 						bw.write(" ");
 72 | 						bw.write(item.summary);
 73 | 					}
 74 | 					bw.write("$|$");
 75 | 					bw.write(item.bugFileLable);
 76 | 					bw.write("$#$");
 77 | 					bw.write(item.reportTimes);
 78 | 					bw.write("\r\n");
 79 | 				}else{
 80 | 					LogUtils.log("BugReportMain", item.commit + ", " + item.id);
 81 | 				}
 82 | 			}
 83 | 			LogUtils.log(TAG, "bugItem written successifully");
 84 | 		} catch (Exception e) {
 85 | 			e.printStackTrace();
 86 | 		} finally {
 87 | 			if (bw != null) {
 88 | 				try {
 89 | 					bw.close();
 90 | 				} catch (IOException e) {
 91 | 					e.printStackTrace();
 92 | 				}
 93 | 			}
 94 | 		}
 95 | 
 96 | 		sourceCodeManager.saveSourceFileList();
 97 | 
 98 | 		LogUtils.log(TAG, "Task finished !!! enjoy^.^");
 99 | 	}
100 | }
101 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/FileUtils.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | 
 3 | import java.io.File;
 4 | import java.io.FileInputStream;
 5 | import java.io.FileNotFoundException;
 6 | import java.io.FileOutputStream;
 7 | import java.io.IOException;
 8 | import java.io.InputStream;
 9 | import java.io.OutputStream;
10 | 
11 | public class FileUtils {
12 | 	public static File copyTo(File sourceFile, File copyToFile){
13 | 		if(sourceFile == null || !sourceFile.exists()){
14 | 			return null;
15 | 		}
16 | 		
17 | 		if(null == copyToFile){
18 | 			return null;
19 | 		}
20 | 		
21 | 		File copyToParent = copyToFile.getParentFile();
22 | 		if(copyToParent == null){
23 | 			return null;
24 | 		}
25 | 		
26 | 		if(!copyToParent.exists()){
27 | 			copyToParent.mkdirs();
28 | 		}
29 | 		
30 | 		if(!copyToFile.exists()){
31 | 			try {
32 | 				copyToFile.createNewFile();
33 | 			} catch (IOException e) {
34 | 				e.printStackTrace();
35 | 			}
36 | 		}
37 | 		
38 | 		 // copy files 
39 |         int byteread = 0; // number of  read bytes 
40 |         InputStream in = null;  
41 |         OutputStream out = null;  
42 |   
43 |         try {  
44 |             in = new FileInputStream(sourceFile);  
45 |             out = new FileOutputStream(copyToFile);  
46 |             byte[] buffer = new byte[1024];  
47 |   
48 |             while ((byteread = in.read(buffer)) != -1) {  
49 |                 out.write(buffer, 0, byteread);  
50 |             }  
51 |             return copyToFile;  
52 |         } catch (FileNotFoundException e) {  
53 |             return null;  
54 |         } catch (IOException e) {  
55 |             return null;  
56 |         } finally {  
57 |             try {  
58 |                 if (out != null)  
59 |                     out.close();  
60 |                 if (in != null)  
61 |                     in.close();  
62 |             } catch (IOException e) {  
63 |                 e.printStackTrace();  
64 |             }  
65 |         } 
66 | 	}
67 | 	
68 | 	
69 | }
70 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/JdtAstUtil.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | import java.io.BufferedInputStream;
 3 | import java.io.FileInputStream;
 4 | import java.io.FileNotFoundException;
 5 | import java.io.IOException;
 6 | 
 7 | import org.eclipse.jdt.core.dom.AST;
 8 | import org.eclipse.jdt.core.dom.ASTParser;
 9 | import org.eclipse.jdt.core.dom.CompilationUnit;
10 | 
11 |   
12 | public class JdtAstUtil {  
13 | 	
14 |     /** 
15 |     * get compilation unit of source code 
16 |     * @param javaFilePath  
17 |     * @return CompilationUnit 
18 |     */  
19 |     public static CompilationUnit getCompilationUnit(String javaFilePath){  
20 |         byte[] input = null;  
21 |         try {  
22 |             BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(javaFilePath));  
23 |             input = new byte[bufferedInputStream.available()];  
24 |                 bufferedInputStream.read(input);  
25 |                 bufferedInputStream.close();  
26 |         } catch (FileNotFoundException e) {  
27 |             e.printStackTrace();  
28 |         } catch (IOException e) {  
29 |             e.printStackTrace();  
30 |         }  
31 |         
32 |         ASTParser astParser = ASTParser.newParser(AST.JLS8);  
33 |         astParser.setSource(new String(input).toCharArray());  
34 |         astParser.setKind(ASTParser.K_COMPILATION_UNIT); 
35 |         CompilationUnit result = (CompilationUnit) (astParser.createAST(null));  
36 |           
37 |         return result;  
38 |     }  
39 | }  


--------------------------------------------------------------------------------
/src/com/cityu/xy/LogUtils.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | 
 3 | import java.io.BufferedWriter;
 4 | import java.io.File;
 5 | import java.io.FileWriter;
 6 | 
 7 | public class LogUtils {
 8 | 	private static boolean mOpen = false;
 9 | 	
10 | 	private static BufferedWriter cBW;
11 | 
12 | 
13 | 	public static boolean isOpen() {
14 | 		return mOpen;
15 | 	}
16 | 
17 | 	public static void setOpen(boolean open) {
18 | 		mOpen = open;
19 | 		System.out.println("log print is " + (open?"open":"close"));
20 | 	}
21 | 	
22 | 	/**
23 | 	 * print log
24 | 	 * @param content
25 | 	 */
26 | 	public static void log(String TAG, String content){
27 | 		if(mOpen){
28 | 			System.out.printf("%s: %s\n", TAG, content);
29 | 		}
30 | 	}
31 | 	
32 | 	/**
33 | 	 * write log to file
34 | 	 * @param content
35 | 	 */
36 | 	public static void logFile(String TAG, String content){
37 | 		if(!mOpen){
38 | 			return;
39 | 		}
40 | 		
41 | 		try{
42 | 			if(cBW == null){
43 | 				File logFile = new File(TAG + "_log.txt"); 
44 | 				if(logFile.exists()){
45 | 					logFile.delete();
46 | 				}
47 | 				cBW = new BufferedWriter(new FileWriter(logFile));
48 | 				
49 | 			}
50 | 			
51 | 			cBW.write(content);
52 | 			cBW.write("\r\n");
53 | 			cBW.flush();
54 | 		}catch(Exception e){
55 | 			e.printStackTrace();
56 | 		}
57 | 	}
58 | 	
59 | }
60 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/SourceCodeManager.java:
--------------------------------------------------------------------------------
  1 | package com.cityu.xy;
  2 | 
  3 | import java.io.File;
  4 | import java.io.FileWriter;
  5 | import java.io.IOException;
  6 | import java.util.ArrayList;
  7 | import java.util.HashMap;
  8 | import java.util.List;
  9 | import java.util.Map;
 10 | 
 11 | import org.eclipse.jgit.api.CheckoutCommand;
 12 | import org.eclipse.jgit.api.Git;
 13 | 
 14 | public class SourceCodeManager {
 15 | //	private final String TAG = SourceCodeManager.class.getSimpleName();
 16 | //	public static final boolean GIT_CHECKOUT = true;
 17 | 	public static final boolean GIT_CHECKOUT = false;
 18 | 
 19 | 
 20 | 
 21 | 		
 22 | 	/**
 23 | 	 * swt
 24 | 	 */
 25 | //	public static final String SOURCE_CODE_DIR = "/Users/xiaoyan/eclipse.platform.swt/";
 26 | //	public static final String LOCAL_FILE_PREFIX = "sourceFile_swt/";
 27 | 	
 28 | 	/**
 29 | 	 * jdt
 30 | 	 */
 31 | //	public static final String SOURCE_CODE_DIR = "/Users/xiaoyan/eclipse.jdt.ui/";
 32 | //	public static final String LOCAL_FILE_PREFIX = "sourceFile_jdt/";
 33 | 	
 34 | 	/**
 35 | 	 * aspectj
 36 | 	 */
 37 | //	public static final String SOURCE_CODE_DIR = "/Users/xiaoyan/org.aspectj/";
 38 | //	public static final String LOCAL_FILE_PREFIX = "sourceFile_aspectj/";
 39 | 	
 40 | 	/**
 41 | 	 * eclipseUI
 42 | 	 */
 43 | //	public static final String SOURCE_CODE_DIR = "/Users/xiaoyan/eclipse.platform.ui/";
 44 | //	public static final String LOCAL_FILE_PREFIX = "sourceFile_eclipseUI/";
 45 | 	
 46 | 	/**
 47 | 	 * tomcat
 48 | 	 */
 49 | 	public static final String SOURCE_CODE_DIR = "/Users/xiaoyan/tomcat/";
 50 | 	public static final String LOCAL_FILE_PREFIX = "sourceFile_tomcat/";
 51 | 	public static final String LOCAL_COPY_SOURCE_CODE = LOCAL_FILE_PREFIX + "sourceFile/";
 52 | 
 53 | 	private static SourceCodeManager mInstance = null;
 54 | 
 55 | 	private List<String> mSourceFileList;
 56 | 	private Map<String, SourceFile> mSourceFileMapping = new HashMap<String, SourceFile>();
 57 | 
 58 | 	private SourceCodeManager() {
 59 | 	};
 60 | 
 61 | 	// Singleton
 62 | 	public static SourceCodeManager getInstance() {
 63 | 		if (mInstance == null) {
 64 | 			synchronized (SourceCodeManager.class) {
 65 | 				if (mInstance == null) {
 66 | 					mInstance = new SourceCodeManager();
 67 | 				}
 68 | 			}
 69 | 		}
 70 | 
 71 | 		return mInstance;
 72 | 	}
 73 | 
 74 | 	public void setSourceFiles(List<String> sourceFiles) {
 75 | 		mSourceFileList = sourceFiles;
 76 | 	}
 77 | 	
 78 | 	public void initSourFileContext(List<BugItem> itemList){
 79 | 		for(BugItem item : itemList){
 80 | 			for(String path : item.files){
 81 | 				SourceFile  sourceFile = mSourceFileMapping.get(path);
 82 | 				if(sourceFile == null){
 83 | 					SourceFile newSourceFile = new SourceFile();
 84 | 					newSourceFile.path = path;
 85 | 					newSourceFile.commintTimeMapping.put(Long.valueOf(item.commintTime), item.commit);
 86 | 					mSourceFileMapping.put(path, newSourceFile);
 87 | 				}else{
 88 | 					sourceFile.commintTimeMapping.put(Long.valueOf(item.commintTime), item.commit);
 89 | //					LogUtils.log(TAG, path);
 90 | 				}
 91 | 				
 92 | 			}
 93 | 		}
 94 | 	}
 95 | 	
 96 | 	/**
 97 | 	 * git all file from github
 98 | 	 * @param items
 99 | 	 * @throws Exception
100 | 	 */
101 | 	public void gitAllSourceCodeFile(List<BugItem> items) throws Exception {
102 | 		Git git = null;
103 | 		git = Git.open(new File(SOURCE_CODE_DIR));
104 | 
105 | 		for (BugItem bugItem : items) {
106 | 			List<String> sourceFiles = bugItem.files;
107 | 
108 | 			for (String fileName : sourceFiles) {
109 | 				if (!fileName.endsWith(".java")) {
110 | 					continue;
111 | 				}
112 | 
113 | 				// pull files corresponding to current version from git
114 | 				try {
115 | 					CheckoutCommand checkoutCommand = git.checkout();
116 | 					checkoutCommand.addPath(fileName);
117 | 					checkoutCommand.setStartPoint(bugItem.commit + "~1");
118 | 					checkoutCommand.call();
119 | 					// }
120 | 				} catch (Exception e) {
121 | 					 e.printStackTrace();
122 | 				} finally {
123 | 					git.close();
124 | 				}
125 | 
126 | 				File file = new File(SourceCodeManager.SOURCE_CODE_DIR, fileName);
127 | 				if (!file.exists()) {
128 | 					// add the newly added files if this files are newly added
129 | 					try {
130 | 						CheckoutCommand checkoutCommand = git.checkout();
131 | 						checkoutCommand.addPath(fileName);
132 | 						checkoutCommand.setStartPoint(bugItem.commit);
133 | 						checkoutCommand.call();
134 | 						git.close();
135 | 
136 | 						File addFile = new File(SourceCodeManager.SOURCE_CODE_DIR, fileName);
137 | 						if (!addFile.exists()) {
138 | 							System.out.println(bugItem.bugId + " " + bugItem.commit + " " + addFile.getAbsolutePath());
139 | 						}
140 | 					} catch (Exception e) {
141 | 						e.printStackTrace();
142 | 					}finally {
143 | 						git.close();
144 | 					}
145 | 				}
146 | 
147 | 				// copy file to target directory
148 | 				if (file.exists()) {
149 | 					String origineFileName = file.getName();
150 | 					String origineAbsoluteName = file.getAbsolutePath();
151 | 					String copyToFileName = origineAbsoluteName.substring(15, origineAbsoluteName.length() - origineFileName.length());
152 | 					File copyToFile = new File(LOCAL_COPY_SOURCE_CODE + copyToFileName + bugItem.commit + " " + origineFileName);
153 | 					FileUtils.copyTo(file, copyToFile);
154 | 				}
155 | 			}
156 | 		}
157 | 	}
158 | 
159 | 	/**
160 | 	 * obtain local file according to bugItem files 
161 | 	 * @param bugItem
162 | 	 * @return
163 | 	 */
164 | 	public List<String> getLocalSourceFile(BugItem bugItem) {
165 | 		if (bugItem == null) {
166 | 			return null;
167 | 		}
168 | 
169 | 		List<String> filePaths = bugItem.files;
170 | 		List<String> localFiles = new ArrayList<String>(filePaths.size());
171 | 
172 | 		for (String path : filePaths) {
173 | 			SourceFile sourceFile = mSourceFileMapping.get(path);
174 | 			String commit = sourceFile.commintTimeMapping.lastEntry().getValue();
175 | 			File file = new File(SOURCE_CODE_DIR, path);
176 | 			String origineFileName = file.getName();
177 | 			String origineAbsoluteName = file.getAbsolutePath();
178 | 			String copyToFileName = origineAbsoluteName.substring(15, origineAbsoluteName.length() - origineFileName.length());
179 | 			File localFile = new File(LOCAL_COPY_SOURCE_CODE + copyToFileName + commit + " " + origineFileName);
180 | 			localFiles.add(localFile.getAbsolutePath());
181 | 		}
182 | 		bugItem.files = localFiles;
183 | 
184 | 		return localFiles;
185 | 	}
186 | 
187 | 	/**
188 | 	 * obtain label
189 | 	 * 
190 | 	 * @param files bugItem's files
191 | 	 * @return label
192 | 	 */
193 | 	public String getBugReportLabel(List<String> files) {
194 | 		int[] labelArray = new int[mSourceFileList.size()];
195 | 
196 | 		boolean isValid = false;
197 | 		for (String fileName : files) {
198 | 			File file = new File(fileName);
199 | 			if (file.exists()) {
200 | 				String path = file.getAbsolutePath();
201 | 				int index = mSourceFileList.indexOf(path);
202 | 				if (index >= 0 && index < mSourceFileList.size()) {
203 | 					labelArray[index] = 1;
204 | 					isValid = true;
205 | 				}
206 | 			}
207 | 		}
208 | 
209 | 		if (isValid) {
210 | 			StringBuffer buffer = new StringBuffer();
211 | 			for (int index = 0; index < labelArray.length; index++) {
212 | 				buffer.append(labelArray[index]);
213 | 			}
214 | 
215 | 			return buffer.toString();
216 | 		} else {
217 | 			return null;
218 | 		}
219 | 	}
220 | 
221 | 	/**
222 | 	 * save source file to text as list
223 | 	 */
224 | 	public void saveSourceFileList() {
225 | 		FileWriter fw = null;
226 | 		try {
227 | 			fw = new FileWriter(new File(SourceCodeManager.LOCAL_FILE_PREFIX + "source_list.txt"));
228 | 			for (String sourceFile : mSourceFileList) {
229 | 				fw.write(sourceFile);
230 | 				fw.write("\r\n");
231 | 			}
232 | 			fw.flush();
233 | 		} catch (Exception e) {
234 | 			e.printStackTrace();
235 | 		} finally {
236 | 			if (fw != null) {
237 | 				try {
238 | 					fw.close();
239 | 				} catch (IOException e) {
240 | 					e.printStackTrace();
241 | 				}
242 | 			}
243 | 		}
244 | 	}
245 | }
246 | 


--------------------------------------------------------------------------------
/src/com/cityu/xy/SourceFile.java:
--------------------------------------------------------------------------------
 1 | package com.cityu.xy;
 2 | 
 3 | import java.util.TreeMap;
 4 | 
 5 | public class SourceFile {
 6 | 	public String path;
 7 | 	
 8 | 	public TreeMap<Long, String> commintTimeMapping = new TreeMap<Long, String>();
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/libs/org.eclipse.jgit-4.6.1.201703071140-r.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yanxiao6/BugLocalization-dataset/1b6caa5d2b382b3f2bf3ca6e419c6cee0c878c36/src/libs/org.eclipse.jgit-4.6.1.201703071140-r.jar


--------------------------------------------------------------------------------