cleanup

Author: adireddy

checkstyle/ChecksInfo.hx

@@ -2,22 +2,17 @@ package checkstyle;
 
 import checkstyle.checks.Check;
 
-typedef CheckInfo = {
-	var name:String;
-	var description:String;
-	var clazz:Class<Check>;
-}
-
 class ChecksInfo {
+
 	var name2info:Map<String, CheckInfo>;
 
-	public function new(){
+	public function new() {
 		name2info = new Map();
 
 		CompileTime.importPackage("checkstyle.checks"); // must be string constant
 		var checksClasses = CompileTime.getAllClasses(Check);
 
-		for (cl in checksClasses){
+		for (cl in checksClasses) {
 			var name = getCheckNameFromClass(cl);
 			var desc = getCheckDescription(cl);
 			name2info[name] = {
@@ -28,28 +23,34 @@ class ChecksInfo {
 		}
 	}
 
-	static function getCheckNameFromClass(cl:Class<Check>){
+	static function getCheckNameFromClass(cl:Class<Check>) {
 		var meta = haxe.rtti.Meta.getType(cl);
 		if (meta.name == null) throw '${Type.getClassName(cl)} have no @name meta.';
 		if (meta.name.length != 1) throw '${Type.getClassName(cl)} @name meta should have exactly one argument';
 		return meta.name[0];
 	}
 
-	public static function getCheckName(check:Check){
+	public static function getCheckName(check:Check) {
 		return getCheckNameFromClass(Type.getClass(check));
 	}
 
-	function getCheckDescription(cl:Class<Check>){
+	function getCheckDescription(cl:Class<Check>) {
 		return haxe.rtti.Meta.getType(cl).desc[0];
 	}
 
-	public function checks(){
+	public function checks() {
 		return name2info.iterator();
 	}
 
-	public function build(name:String){
-		if (! name2info.exists(name)) throw 'Unknown check: $name';
+	public function build(name:String) {
+		if (!name2info.exists(name)) throw 'Unknown check: $name';
 		var cl = name2info[name].clazz;
-		return Type.createInstance(cl,[]);
+		return Type.createInstance(cl, []);
 	}
+}
+
+typedef CheckInfo = {
+	var name:String;
+	var description:String;
+	var clazz:Class<Check>;
 }

checkstyle/ComplexTypeUtils.hx

@@ -8,50 +8,45 @@ import haxeparser.Data.EnumFlag;
 import haxeparser.Data.EnumConstructor;
 import haxe.macro.Expr;
 
-//FIXME ComplexTypeUtils differ from ExprUtils ONLY in place for callback call and it's type. Maybe it's possible to generate such functions.
 class ComplexTypeUtils {
 
-	public static function walkFile(file:{pack: Array<String>, decls: Array<TypeDecl> }, cb:ComplexType -> Void) {
-		for (decl in file.decls){
-			walkTypeDecl(decl, cb);
-		}
+	public static function walkFile(file:{pack:Array<String>, decls:Array<TypeDecl> }, cb:ComplexType -> Void) {
+		for (decl in file.decls) walkTypeDecl(decl, cb);
 	}
 
 	public static function walkTypeDecl(td:TypeDecl, cb:ComplexType -> Void) {
 		switch(td.decl){
-		case EClass(d):
-			walkClass(d,cb);
-		case EEnum(d):
-			walkEnum(d,cb);
-		case EAbstract(a):
-			walkAbstract(a,cb);
-		case EImport(sl, mode):
-			walkImport(sl, mode,cb);
-		case ETypedef(d):
-			walkTypedef(d,cb);
-		case EUsing(path):
-			walkTypePath(path,cb);
+			case EClass(d):
+				walkClass(d, cb);
+			case EEnum(d):
+				walkEnum(d, cb);
+			case EAbstract(a):
+				walkAbstract(a, cb);
+			case EImport(sl, mode):
+				walkImport(sl, mode, cb);
+			case ETypedef(d):
+				walkTypedef(d, cb);
+			case EUsing(path):
+				walkTypePath(path, cb);
 		}
 	}
 
-	static function walkMeta(meta:Metadata, cb:ComplexType -> Void){
-		for (m in meta) for (p in m.params) walkExpr(p,cb);
+	static function walkMeta(meta:Metadata, cb:ComplexType -> Void) {
+		for (m in meta) for (p in m.params) walkExpr(p, cb);
 	}
 
-	static function walkCommonDefinition<A,B> (d:Definition<A, B>, cb:ComplexType -> Void) {
-		for (p in d.params) walkTypeParamDecl(p,cb);
+	static function walkCommonDefinition<A, B>(d:Definition<A, B>, cb:ComplexType -> Void) {
+		for (p in d.params) walkTypeParamDecl(p, cb);
 		walkMeta(d.meta, cb);
 	}
 
 	public static function walkClass(d:Definition<ClassFlag, Array<Field>>, cb:ComplexType -> Void) {
 		walkCommonDefinition(d, cb);
 		for (f in d.flags) switch f {
-			case HExtends(t) | HImplements(t): walkTypePath(t,cb);
+			case HExtends(t) | HImplements(t): walkTypePath(t, cb);
 			default:
 		}
-		for (f in d.data) {
-			walkField(f,cb);
-		}
+		for (f in d.data) walkField(f, cb);
 	}
 
 	public static function walkEnum(d:Definition<EnumFlag, Array<EnumConstructor>>, cb:ComplexType -> Void) {
@@ -61,22 +56,18 @@ class ComplexTypeUtils {
 			for (arg in ec.args) {
 				walkComplexType(arg.type, cb);
 			}
-			for (param in ec.params) {
-				walkTypeParamDecl(param, cb);
-			}
+			for (param in ec.params) walkTypeParamDecl(param, cb);
 			if (ec.type != null) walkComplexType(ec.type, cb);
 		}
 	}
 
 	public static function walkAbstract(d:Definition<AbstractFlag, Array<Field>>, cb:ComplexType -> Void) {
 		walkCommonDefinition(d, cb);
 		for (f in d.flags) switch f {
-			case AFromType(ct) | AToType(ct) | AIsType(ct): walkComplexType(ct,cb);
+			case AFromType(ct) | AToType(ct) | AIsType(ct): walkComplexType(ct, cb);
 			default:
 		}
-		for (f in d.data) {
-			walkField(f,cb);
-		}
+		for (f in d.data) walkField(f, cb);
 	}
 
 	public static function walkImport(sl, mode, cb:ComplexType -> Void) {
@@ -105,12 +96,8 @@ class ComplexTypeUtils {
 	}
 
 	public static function walkTypeParamDecl(tp:TypeParamDecl, cb:ComplexType -> Void) {
-		if (tp.constraints != null) {
-			for (c in tp.constraints) walkComplexType(c, cb);
-		}
-		if (tp.params != null) {
-			for (t in tp.params) walkTypeParamDecl(t, cb);
-		}
+		if (tp.constraints != null) for (c in tp.constraints) walkComplexType(c, cb);
+		if (tp.params != null) for (t in tp.params) walkTypeParamDecl(t, cb);
 	}
 
 	public static function walkFunction(f:Function, cb:ComplexType -> Void) {
@@ -120,17 +107,11 @@ class ComplexTypeUtils {
 		}
 		if (f.ret != null) walkComplexType(f.ret, cb);
 		if (f.expr != null) walkExpr(f.expr, cb);
-		if (f.params != null) {
-			for (tp in f.params) {
-				walkTypeParamDecl(tp, cb);
-			}
-		}
+		if (f.params != null) for (tp in f.params) walkTypeParamDecl(tp, cb);
 	}
 
 	public static function walkCase(c:Case, cb:ComplexType -> Void) {
-		for (v in c.values) {
-			walkExpr(v, cb);
-		}
+		for (v in c.values) walkExpr(v, cb);
 		if (c.guard != null) walkExpr(c.guard, cb);
 		if (c.expr != null) walkExpr(c.expr, cb);
 	}
@@ -181,33 +162,23 @@ class ComplexTypeUtils {
 			case EField(e, field): walkExpr(e, cb);
 			case EParenthesis(e): walkExpr(e, cb);
 			case EObjectDecl(fields):
-				for (f in fields) {
-					walkExpr(f.expr, cb);
-				}
+				for (f in fields) walkExpr(f.expr, cb);
 			case EArrayDecl(values):
-				for (v in values) {
-					walkExpr(v, cb);
-				}
+				for (v in values) walkExpr(v, cb);
 			case ECall(e, params):
 				walkExpr(e, cb);
-				for (p in params) {
-					walkExpr(p, cb);
-				}
+				for (p in params) walkExpr(p, cb);
 			case ENew(t, params):
 				walkTypePath(t, cb);
-				for (p in params) {
-					walkExpr(p, cb);
-				}
+				for (p in params) walkExpr(p, cb);
 			case EUnop(op, postFix, e): walkExpr(e, cb);
 			case EVars(vars):
 				for (v in vars) {
 					walkVar(v, cb);
 				}
 			case EFunction(name, f): walkFunction(f, cb);
 			case EBlock(exprs):
-				for (e in exprs) {
-					walkExpr(e, cb);
-				}
+				for (e in exprs) walkExpr(e, cb);
 			case EFor(it, expr): walkExpr(it, cb); walkExpr(expr, cb);
 			case EIn(e1, e2): walkExpr(e1, cb); walkExpr(e2, cb);
 			case EIf(econd, eif, eelse):
@@ -218,9 +189,7 @@ class ComplexTypeUtils {
 			case ESwitch(e, cases, edef):
 				walkExpr(e, cb);
 				for (c in cases) walkCase(c, cb);
-				if (edef != null && edef.expr != null){
-					walkExpr(edef, cb);
-				}
+				if (edef != null && edef.expr != null) walkExpr(edef, cb);
 			case ETry(e, catches):
 				walkExpr(e, cb);
 				for (c in catches) walkCatch(c, cb);
@@ -243,11 +212,8 @@ class ComplexTypeUtils {
 				walkExpr(e, cb);
 				walkComplexType(t, cb);
 			case EMeta(s, e):
-				if (s.params != null) {
-					for (mp in s.params) walkExpr(mp, cb);
-				}
+				if (s.params != null) for (mp in s.params) walkExpr(mp, cb);
 				walkExpr(e, cb);
 		}
 	}
-
-}
+}

checkstyle/Main.hx

@@ -16,40 +16,40 @@ class Main {
 		var cwd;
 		var oldCwd = null;
 
-		try{
+		try {
 			args = Sys.args();
 			cwd = Sys.getCwd();
-			if (Sys.getEnv("HAXELIB_RUN") != null){
+			if (Sys.getEnv("HAXELIB_RUN") != null) {
 				cwd = args.pop();
 				oldCwd = Sys.getCwd();
 			}
-			if (oldCwd != null) Sys.setCwd(cwd); // FIXME instead of this one should gracefully parse absolute-relative path
+			if (oldCwd != null) Sys.setCwd(cwd);
 
 			var main = new Main();
 			main.run(args);
 		}
-		catch(e:Dynamic){
+		catch(e:Dynamic) {
 			trace(e);
 			trace(CallStack.toString(CallStack.exceptionStack()));
 		}
-		if (oldCwd != null) Sys.setCwd(oldCwd); // FIXME instead of this one should gracefully parse absolute-relative path
+		if (oldCwd != null) Sys.setCwd(oldCwd);
 	}
 
 	var reporter:IReporter;
 	var info:ChecksInfo;
 	var checker:Checker;
 
 	static var report_type:String = "default";
-	static var path:String = "static_analysis.xml";
+	static var path:String = "check-style-report.xml";
 	static var style:String = "";
 
-	function new(){
+	function new() {
 		reporter = new Reporter();
 		info = new ChecksInfo();
 		checker = new Checker();
 	}
 
-	function run(args:Array<String>){
+	function run(args:Array<String>) {
 		var files:Array<String> = [];
 		var _configPath:String = null;
 
@@ -85,11 +85,8 @@ class Main {
 			toProcess.push({name:file,content:code});
 		}
 
-		if (_configPath == null){
-			addAllChecks();
-		}
+		if (_configPath == null) addAllChecks();
 		else {
-			//TODO split config loading to separate class
 			var configText = File.getContent(_configPath);
 			var config = Json.parse(configText);
 			var checks:Array<Dynamic> = config.checks;
@@ -98,7 +95,6 @@ class Main {
 				if (checkConf.props != null){
 					var props = Reflect.fields(checkConf.props);
 					for (prop in props){
-						//FIXME check available properties and their types
 						var val = Reflect.field(checkConf.props, prop);
 						Reflect.setField(check, prop, val);
 					}
@@ -110,48 +106,37 @@ class Main {
 		checker.process(toProcess);
 	}
 
-	function addAllChecks():Void{
-		for (check in info.checks()){
-			checker.addCheck(info.build(check.name));
-		}
+	function addAllChecks():Void {
+		for (check in info.checks()) checker.addCheck(info.build(check.name));
 	}
 
-	function listChecks():Void{
-		for (check in info.checks()){
-			Sys.println('${check.name}: ${check.description}');
-		}
+	function listChecks():Void {
+		for (check in info.checks()) Sys.println('${check.name}: ${check.description}');
 	}
 
-	//FIXME some macro maybe?
 	static function listReporters():Void {
 		Sys.println("default - Default reporter");
 		Sys.println("xml - Checkstyle-like XML reporter");
 		Sys.exit(0);
 	}
 
-	//FIXME some macro maybe?
-	static function createReporter():IReporter{
-		return switch(report_type){
-		case "xml": new XMLReporter(path, style);
-		case "default": new Reporter();
-		default: throw "Unknown reporter";
+	static function createReporter():IReporter {
+		return switch(report_type) {
+			case "xml": new XMLReporter(path, style);
+			case "default": new Reporter();
+			default: throw "Unknown reporter";
 		}
 	}
 
-	private static function pathJoin(s:String, t:String):String{
-		//FIXME
+	private static function pathJoin(s:String, t:String):String {
 		return s + "/" + t;
 	}
 
 	private static function traverse(node:String , files:Array<String>) {
-		if (FileSystem.isDirectory(node)){
+		if (FileSystem.isDirectory(node)) {
 			var nodes = FileSystem.readDirectory(node);
-			for (child in nodes){
-				traverse(pathJoin(node,child),files);
-			}
-		}
-		else if (node.substr(-3) == ".hx"){
-			files.push(node);
+			for (child in nodes) traverse(pathJoin(node,child), files);
 		}
+		else if (node.substr(-3) == ".hx") files.push(node);
 	}
 }