added enforcePublicPrivate to PublicPrivateCheck to enforce access modifiers

added enforceReturnType to ReturnCheck to enforce a return type in function declaration

Author: AlexHaxe

README.md

@@ -104,13 +104,16 @@ More information in [wiki page](https://github.com/adireddy/haxe-checkstyle/wiki
 		{
 			"type": "PublicPrivate",
 			"props": {
-				"severity": "INFO"
+				"severity": "INFO",
+				"enforcePublicPrivate": false
 			}
 		},
 		{
 			"type": "Return",
 			"props": {
-				"severity": "INFO"
+				"severity": "INFO",
+				"allowEmptyReturn": true,
+				"enforceReturnType": false
 			}
 		},
 		{

build.hxml

@@ -3,7 +3,7 @@
 -lib hxparse:3.0.0
 -lib haxeparser
 -lib haxeparser-substituted:1.0.1
--lib compiletime:2.5.0
+-lib compiletime:2.5.1
 -lib hxargs:3.0.0
 
 --each
@@ -14,4 +14,4 @@
 --next
 -cp test
 -main TestMain
---interp
+--interp

checkstyle/checks/PublicPrivateCheck.hx

@@ -9,6 +9,7 @@ import haxe.macro.Expr;
 class PublicPrivateCheck extends Check {
 
 	public var severity:String = "INFO";
+	public var enforcePublicPrivate:Bool = false;
 
 	override function _actualRun() {
 		for (td in _checker.ast.decls) {
@@ -30,16 +31,32 @@ class PublicPrivateCheck extends Check {
 	}
 
 	function checkInterfaceField(f:Field) {
-		if (f.access.indexOf(APublic) > -1) {
-			_warnPublicKeyword(f.name, f.pos);
-			return;
+		if (enforcePublicPrivate) {
+			if (f.access.indexOf(APublic) < 0) {
+				_warnPublicKeywordMissing(f.name, f.pos);
+				return;
+			}
+		}
+		else {
+			if (f.access.indexOf(APublic) > -1) {
+				_warnPublicKeyword(f.name, f.pos);
+				return;
+			}
 		}
 	}
 
 	function checkField(f:Field) {
-		if (f.access.indexOf(APrivate) > -1) {
-			_warnPrivateKeyword(f.name, f.pos);
-			return;
+		if (enforcePublicPrivate) {
+			if ((f.access.indexOf(APublic) < 0) && (f.access.indexOf(APrivate) < 0)) {
+				_warnPrivateKeywordMissing(f.name, f.pos);
+				return;
+			}
+		}
+		else {
+			if (f.access.indexOf(APrivate) > -1) {
+				_warnPrivateKeyword(f.name, f.pos);
+				return;
+			}
 		}
 	}
 
@@ -50,4 +67,12 @@ class PublicPrivateCheck extends Check {
 	function _warnPublicKeyword(name:String, pos:Position) {
 		logPos('No need of public keyword: ${name} (fields are by default public in interfaces)', pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+
+	function _warnPrivateKeywordMissing(name:String, pos:Position) {
+		logPos('Missing private keyword: ${name}', pos, Reflect.field(SeverityLevel, severity));
+	}
+
+	function _warnPublicKeywordMissing(name:String, pos:Position) {
+		logPos('Missing public keyword: ${name}', pos, Reflect.field(SeverityLevel, severity));
+	}
+}

checkstyle/checks/ReturnCheck.hx

@@ -10,6 +10,7 @@ class ReturnCheck extends Check {
 
 	public var severity:String = "INFO";
 	public var allowEmptyReturn:Bool = true;
+	public var enforceReturnType:Bool = false;
 
 	override function _actualRun() {
 		for (td in _checker.ast.decls) {
@@ -28,8 +29,15 @@ class ReturnCheck extends Check {
 	}
 
 	function checkField(f:Field) {
-		if (Std.string(f.kind).indexOf("ret => TPath({ name => Void") > -1) {
-			_warnVoid(f.name, f.pos);
+		if (enforceReturnType) {
+			if (Std.string(f.kind).indexOf("ret => null") > -1) {
+				_warnReturnTypeMissing(f.name, f.pos);
+			}
+		} 
+		else {
+			if (Std.string(f.kind).indexOf("ret => TPath({ name => Void") > -1) {
+				_warnVoid(f.name, f.pos);
+			}
 		}
 		if (allowEmptyReturn && Std.string(f.kind).indexOf("EReturn(null)") > -1) return;
 		if (Std.string(f.kind).indexOf("expr => EReturn") > -1 && Std.string(f.kind).indexOf("ret => null") > -1) {
@@ -44,4 +52,8 @@ class ReturnCheck extends Check {
 	function _warnNoReturnType(name:String, pos:Position) {
 		logPos('Return type not specified when returning a value for function: ${name}', pos, Reflect.field(SeverityLevel, severity));
 	}
-}
+
+	function _warnReturnTypeMissing(name:String, pos:Position) {
+		logPos('Return type not specified for function: ${name}', pos, Reflect.field(SeverityLevel, severity));
+	}
+}

run.n

@@ -7,6 +7,8 @@ class PublicPrivateCheckTest extends CheckTestCase {
 	public function testCorrectUsage() {
 		var msg = checkMessage(PublicPrivateTests.TEST, new PublicPrivateCheck());
 		assertEquals(msg, '');
+		msg = checkMessage(PublicPrivateTests.TEST3, new PublicPrivateCheck());
+		assertEquals(msg, '');
 	}
 
 	public function testNormalClass() {
@@ -18,6 +20,34 @@ class PublicPrivateCheckTest extends CheckTestCase {
 		var msg = checkMessage(PublicPrivateTests.TEST2, new PublicPrivateCheck());
 		assertEquals(msg, 'No need of public keyword: a (fields are by default public in interfaces)');
 	}
+
+	public function testClassWithEnforce() {
+		var check = new PublicPrivateCheck ();
+		check.enforcePublicPrivate = true;
+		var msg = checkMessage(PublicPrivateTests.TEST1, check);
+		assertEquals(msg, '');
+	}
+
+	public function testClassWithEnforceMissing() {
+		var check = new PublicPrivateCheck ();
+		check.enforcePublicPrivate = true;
+		var msg = checkMessage(PublicPrivateTests.TEST, check);
+		assertEquals(msg, 'Missing private keyword: _onUpdate');
+	}
+
+	public function testInterfaceWithEnforce() {
+		var check = new PublicPrivateCheck ();
+		check.enforcePublicPrivate = true;
+		var msg = checkMessage(PublicPrivateTests.TEST2, check);
+		assertEquals(msg, '');
+	}
+
+	public function testInterfaceWithEnforceMissing() {
+		var check = new PublicPrivateCheck ();
+		check.enforcePublicPrivate = true;
+		var msg = checkMessage(PublicPrivateTests.TEST3, check);
+		assertEquals(msg, 'Missing public keyword: a');
+	}
 }
 
 class PublicPrivateTests {
@@ -42,4 +72,9 @@ class PublicPrivateTests {
 	interface Test {
 		public var a:Int;
 	}";
-}
+
+	public static inline var TEST3:String = "
+	interface Test {
+		var a:Int;
+	}";
+}

test/PublicPrivateCheckTest.hx

@@ -18,6 +18,23 @@ class ReturnCheckTest extends CheckTestCase {
 		var msg = checkMessage(ReturnTests.TEST3, new ReturnCheck());
 		assertEquals(msg, '');
 	}
+
+	public function testEnforceReturnType() {
+		var check = new ReturnCheck ();
+		check.enforceReturnType = true;
+		var msg = checkMessage(ReturnTests.TEST1, check);
+		assertEquals(msg, '');
+	}
+
+	public function testReturnTypeAllowEmptyReturn() {
+		var check = new ReturnCheck ();
+		check.allowEmptyReturn = false;
+		var msg = checkMessage(ReturnTests.TEST2, check);
+		assertEquals(msg, 'Return type not specified when returning a value for function: test1');
+
+		msg = checkMessage(ReturnTests.TEST3, check);
+		assertEquals(msg, 'Return type not specified when returning a value for function: test2');
+	}
 }
 
 class ReturnTests {
@@ -39,4 +56,4 @@ class ReturnTests {
 			return;
 		}
 	}";
-}
+}