natas_hw
/
slf4j
mirror of https://github.com/qos-ch/slf4j
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

on going work

This commit is contained in:
Jean-Noel Charpin 2007-06-08 15:22:51 +00:00
parent 8b7b2c479f
commit 804d48d803
5 changed files with 71 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
slf4j-converter/src/main/java/org/slf4j/converter/AbstractMatcher.java
View File

@ -1,7 +1,7 @@
package org.slf4j.converter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@ -11,10 +11,13 @@ public abstract class AbstractMatcher {
protected Logger logger;
protected HashMap<Pattern, String> rulesMap;
protected TreeMap<PatternWrapper, String> rulesMap;
protected Writer writer;
public AbstractMatcher() {
}
public static AbstractMatcher getMatcherImpl() {
// TODO criterias
return new JCLMatcher();
@ -25,23 +28,32 @@ public abstract class AbstractMatcher {
}
public void matches(String text) {
PatternWrapper patternWrapper;
Pattern pattern;
Matcher matcher;
String replacement;
Iterator rulesIter = rulesMap.keySet().iterator();
boolean found = false;
while (rulesIter.hasNext()) {
pattern = (Pattern) rulesIter.next();
matcher = pattern.matcher(text);//
if (matcher.find()) {
logger.info("found " + text);
replacement = (String) rulesMap.get(pattern);
writer.rewrite(matcher, replacement);
found = true;
while (rulesIter.hasNext()) {
patternWrapper = (PatternWrapper) rulesIter.next();
pattern = patternWrapper.getPattern();
matcher = pattern.matcher(text);
if (matcher.matches()) {
logger.info("match " + text);
replacement = (String) rulesMap.get(patternWrapper);
writer.rewrite(matcher, replacement);
found = true;
break;
}
}
// else if (matcher.find()) {
// logger.info("found " + text + " pattern " + pattern.toString());
// replacement = (String) rulesMap.get(patternWrapper);
// writer.rewrite(matcher, replacement);
// found = true;
// break;
// }
}
if(!found){
if (!found) {
writer.write(text);
}
}

2
slf4j-converter/src/main/java/org/slf4j/converter/Converter.java
View File

@ -187,7 +187,7 @@ public class Converter {
while (itFile.hasNext()) {
File currentFile = itFile.next();
File newFile = new File(currentFile.getAbsolutePath()+"new");
logger.info("reading file " + currentFile.getAbsolutePath());
//logger.info("reading file " + currentFile.getAbsolutePath());
try {
boolean isEmpty = false;
writer.initFileWriter(newFile);

229
slf4j-converter/src/main/java/org/slf4j/converter/Converterold.java
View File

@ -1,229 +0,0 @@
package org.slf4j.converter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;
import java.nio.channels.FileChannel;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Converterold {
private Logger logger;
private List<File> javaFiles;
private String source;
private String destination;
private static Pattern regex = Pattern.compile("converter");
/**
* @param args
*/
public static void main(String[] args) {
Converterold converter = new Converterold();
converter.init();
converter.getPaths();
File fileSource = converter.initSource();
File fileDest = converter.initDestination();
converter.copy(fileSource);
converter.selectFiles(fileDest);
converter.convert(converter.javaFiles);
}
public void init() {
logger = LoggerFactory.getLogger(Converterold.class);
}
/**
*
*
*/
private void getPaths() {
source = "c:/projets/slf4j/slf4j-converter/src";
destination = "c:/temp";
}
/**
*
* @return
*/
private File initSource() {
File fileSource = new File(source);
if (!fileSource.isDirectory()) {
logger.info("source path is not a valid source directory");
}
return fileSource;
}
/**
*
* @return
*/
private File initDestination() {
File fileDest = new File(destination);
if (fileDest.exists()) {
delete(fileDest);
}
fileDest.mkdir();
return fileDest;
}
/**
*
* @param fdest
*/
private void delete(File fdest) {
if (fdest.isDirectory()) {
File[] files = fdest.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
delete(files[i]);
}
}
fdest.delete();
logger.info("Deleting " + fdest.getName());
} else {
logger.info("Deleting " + fdest.getName());
fdest.delete();
}
}
/**
*
* @param fsource
*/
private void copy(File fsource) {
String curentFileName = fsource.getAbsolutePath()
.substring(source.length());
File fdest = new File(destination + "/" + curentFileName);
if (fsource.isDirectory()) {
logger.info("Current directory " + fsource.getAbsolutePath());
fdest.mkdir();
logger.info("New directory " + fdest.getAbsolutePath());
File[] files = fsource.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
copy(files[i]);
}
}
} else {
try {
FileInputStream fis = new FileInputStream(fsource);
FileOutputStream fos = new FileOutputStream(fdest);
FileChannel channelSource = fis.getChannel();
FileChannel channelDest = fos.getChannel();
if (channelSource.isOpen() && channelDest.isOpen()) {
channelSource.transferTo(0, channelSource.size(), channelDest);
logger.info("file " + fsource.getName() + " transfered");
channelSource.close();
channelDest.close();
} else {
logger.error("error copying file " + fsource.getAbsolutePath());
}
} catch (FileNotFoundException exc) {
logger.error(exc.toString());
} catch (IOException e) {
logger.error(e.toString());
}
}
}
/**
*
* @param file
* @return
*/
private List<File> selectFiles(File file) {
if (javaFiles == null) {
javaFiles = new ArrayList<File>();
}
if (file.isDirectory()) {
File[] files = file.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
selectFiles(files[i]);
}
}
} else {
if (file.getName().endsWith(".java")) {
javaFiles.add(file);
logger.info("Adding java file " + file.getAbsolutePath());
}
}
return javaFiles;
}
/**
*
* @param lstFiles
*/
private void convert(List<File> lstFiles) {
Iterator<File> itFile = lstFiles.iterator();
while (itFile.hasNext()) {
File currentFile = itFile.next();
logger.info("reading file " + currentFile.getAbsolutePath());
try {
boolean isEmpty = false;
FileReader freader = new FileReader(currentFile);
BufferedReader breader = new BufferedReader(freader);
String line = breader.readLine();
logger.info("reading line " + line);
while (!isEmpty) {
line = breader.readLine();
if (line != null) {
logger.info("reading line " + line);
Matcher matcher = isMatching(line);
if (matcher != null) {
replace(matcher, line);
}
} else {
isEmpty = true;
}
}
} catch (IOException exc) {
logger.error("error reading file " + exc);
}
}
}
public Matcher isMatching(String line) {
Matcher matcher = regex.matcher(line);
if (matcher.find()) {
logger.info("found regex in" + line);
return matcher;
}
// if(matcher.matches()){
// logger.info("found regex " + line);
// return true;
// }
return null;
}
/**
* Rewrite the line
*
* @param line
*/
public void replace(Matcher matcher, String line) {
// String replacement = getReplacement(regex);
logger.info("replacing into" + line);
line = matcher.replaceAll("");
logger.info("new line " + line);
}
}

24
slf4j-converter/src/main/java/org/slf4j/converter/JCLMatcher.java
View File

@ -1,5 +1,6 @@
package org.slf4j.converter;
import java.util.TreeMap;
import java.util.HashMap;
import java.util.regex.Pattern;
@ -7,15 +8,28 @@ import org.slf4j.LoggerFactory;
public class JCLMatcher extends AbstractMatcher {
private static PatternWrapper p1 = new PatternWrapper("1",Pattern.compile("import org.apache.commons.logging.LogFactory;"));
private static PatternWrapper p2 = new PatternWrapper("2",Pattern.compile("import org.apache.commons.logging.Log"));
private static PatternWrapper p3 = new PatternWrapper("3",Pattern.compile("LogFactory.getFactory().getInstance"));
private static PatternWrapper p4 = new PatternWrapper("4",Pattern.compile("LogFactory.getLog"));
private static PatternWrapper p5 = new PatternWrapper("5",Pattern.compile("Log"));
//private static Pattern p6 = new PatternWrapper("6",Pattern.compile("fatal\("));
//private static Pattern p7 = new PatternWrapper("7",Pattern.compile("isFatalEnabled\("));
public JCLMatcher() {
super();
logger = LoggerFactory.getLogger(JCLMatcher.class);
logger = LoggerFactory.getLogger(JCLMatcher.class);
initRules();
}
protected void initRules() {
rulesMap = new HashMap<Pattern, String>();
rulesMap.put(Pattern.compile("import org.slf4j.Logger;"), "import org.toto.Log;");
rulesMap.put(Pattern.compile("Logger"), "Log");
protected void initRules() {
rulesMap = new TreeMap<PatternWrapper, String>();
rulesMap.put(p1,"import org.slf4j.LoggerFactory;");
rulesMap.put(p2,"import org.slf4j.Logger;");
rulesMap.put(p3,"LoggerFactory.getLogger");
rulesMap.put(p4,"LoggerFactory.getLogger");
rulesMap.put(p5,"Logger");
// rulesMap.put(p6,"error(");
// rulesMap.put(p7,"isErrorEnabled(");
}
}

27
slf4j-converter/src/main/java/org/slf4j/converter/PatternWrapper.java Normal file
View File

@ -0,0 +1,27 @@
package org.slf4j.converter;
import java.util.regex.Pattern;
public class PatternWrapper implements Comparable {
private String index;
private Pattern pattern;
public PatternWrapper(String index, Pattern pattern){
this.index = index;
this.pattern = pattern;
}
public String getIndex(){
return index;
}
public Pattern getPattern(){
return pattern;
}
public int compareTo(Object o) {
String oIndex = ((PatternWrapper)o).index;
return this.index.compareTo(oIndex);
}
}