added more checks for automatic coding style detection (#414)

* added more checks for automatic coding style detection

.editorconfig

@@ -10,4 +10,8 @@ trim_trailing_whitespace = true
 
 [*.hx]
 end_of_line = lf
-charset = utf-8
+charset = utf-8
+
+[.travis.yml]
+indent_style = space
+indent_size = 2

.travis.yml

@@ -1,5 +1,5 @@
 git:
-    depth: 1
+  depth: 1
 
 language: haxe
 haxe:

CHANGES.md

@@ -1,6 +1,7 @@
 ## dev branch / next version (2.x.x)
 
 - New command line option `-show-parser-errors` to include parser errors into checkstyle results (default: off) [#413](https://github.com/HaxeCheckstyle/haxe-checkstyle/issues/413)
+- Added more checks for automatic coding style detection [#414](https://github.com/HaxeCheckstyle/haxe-checkstyle/issues/414)
 - Fixed handling of `Arrow` in type names in TokenTree [#413](https://github.com/HaxeCheckstyle/haxe-checkstyle/issues/413)
 - Fixed handling of `Dot` after `KwdNew` in TokenTree [#413](https://github.com/HaxeCheckstyle/haxe-checkstyle/issues/413)
 - Improved handling of file content and `class` parsing in TokenTree [#413](https://github.com/HaxeCheckstyle/haxe-checkstyle/issues/413)

checkstyle.json

@@ -169,12 +169,6 @@
             },
             "type": "LocalVariableName"
         },
-        {
-            "props": {
-                "ignoreNumbers": [-1, 0, 1, 2, 3, 4.0, 5, 8, 10, 13, 21, 34, 100]
-            },
-            "type": "MagicNumber"
-        },
         {
             "props": {
                 "ignoreExtern": true,

resources/default-config.json

@@ -465,13 +465,13 @@
 		},
 		{
 			"props": {
-				"spaceIfCondition": 0,
+				"spaceIfCondition": "should",
 				"spaceAroundBinop": true,
-				"spaceForLoop": 0,
+				"spaceForLoop": "should",
 				"ignoreRangeOperator": true,
-				"spaceWhileLoop": 0,
-				"spaceCatch": 0,
-				"spaceSwitchCase": 0,
+				"spaceWhileLoop": "should",
+				"spaceCatch": "should",
+				"spaceSwitchCase": "should",
 				"noSpaceAroundUnop": true
 			},
 			"type": "Spacing"

src/checkstyle/checks/literal/StringLiteralCheck.hx

@@ -56,6 +56,20 @@ class StringLiteralCheck extends Check {
 				logPos('String "$s" uses single quotes instead of double quotes', pos);
 		}
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "policy",
+				values: [DOUBLE_AND_INTERPOLATION, ONLY_SINGLE, ONLY_DOUBLE]
+			},
+			{
+				propertyName: "allowException",
+				values: [false, true]
+			}]
+		}];
+	}
 }
 
 @:enum

src/checkstyle/checks/metrics/CyclomaticComplexityCheck.hx

@@ -14,8 +14,8 @@ class CyclomaticComplexityCheck extends Check {
 	public function new() {
 		super(AST);
 		thresholds = [
-			{ severity : "WARNING", complexity : DEFAULT_COMPLEXITY_WARNING },
-			{ severity : "ERROR", complexity : DEFAULT_COMPLEXITY_ERROR }
+			{ severity : WARNING, complexity : DEFAULT_COMPLEXITY_WARNING },
+			{ severity : ERROR, complexity : DEFAULT_COMPLEXITY_ERROR }
 		];
 		categories = [Category.COMPLEXITY];
 		points = 13;
@@ -90,6 +90,31 @@ class CyclomaticComplexityCheck extends Check {
 	function notify(method:Target, complexity:Int, risk:Threshold) {
 		logPos('Method "${method.name}" is too complex (score: $complexity).', method.pos, risk.severity);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "thresholds",
+				values: [[
+					{ severity : WARNING, complexity : 6 },
+					{ severity : ERROR, complexity : 16 }
+				],
+				[
+					{ severity : WARNING, complexity : 11 },
+					{ severity : ERROR, complexity : 21 }
+				],
+				[
+					{ severity : WARNING, complexity : 16 },
+					{ severity : ERROR, complexity : 26 }
+				],
+				[
+					{ severity : WARNING, complexity : 21 },
+					{ severity : ERROR, complexity : 31 }
+				]]
+			}]
+		}];
+	}
 }
 
 typedef Target = {
@@ -99,6 +124,6 @@ typedef Target = {
 }
 
 typedef Threshold = {
-	var severity:String;
+	var severity:SeverityLevel;
 	var complexity:Int;
 }

src/checkstyle/checks/size/FileLengthCheck.hx

@@ -24,4 +24,14 @@ class FileLengthCheck extends Check {
 		}
 		if (checker.lines.length > max) log('File length is ${checker.lines.length} lines (max allowed is ${max})', checker.lines.length, 0);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "max",
+				values: [for (i in 0...7) 8 * 100 + i * 100 * 2]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/size/LineLengthCheck.hx

@@ -27,4 +27,14 @@ class LineLengthCheck extends Check {
 			}
 		}
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "max",
+				values: [for (i in 0...7) 8 * 10 + i * 10 * 2]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/size/MethodCountCheck.hx

@@ -44,4 +44,22 @@ class MethodCountCheck extends Check {
 			return;
 		}
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "maxTotal",
+				values: [for (i in 0...21) (2 + i) * 5]
+			},
+			{
+				propertyName: "maxPrivate",
+				values: [for (i in 0...21) (2 + i) * 5]
+			},
+			{
+				propertyName: "maxPublic",
+				values: [for (i in 0...21) (2 + i) * 5]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/size/MethodLengthCheck.hx

@@ -74,4 +74,18 @@ class MethodLengthCheck extends Check {
 	function warnFunctionLength(len:Int, name:String, pos:Position) {
 		logPos('Method `${name}` length is ${len} lines (max allowed is ${max})', pos);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "max",
+				values: [for (i in 0...17) 2 * 10 + i * 5]
+			},
+			{
+				propertyName: "countEmpty",
+				values: [true, false]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/size/ParameterNumberCheck.hx

@@ -35,4 +35,18 @@ class ParameterNumberCheck extends Check {
 	function warnMaxParameter(name:String, pos:Position) {
 		logPos('Too many parameters for function: ${name} (> ${max})', pos);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "max",
+				values: [for (i in 4...15) i]
+			},
+			{
+				propertyName: "ignoreOverriddenMethods",
+				values: [true, false]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/type/AnonymousCheck.hx

@@ -44,4 +44,14 @@ class AnonymousCheck extends Check {
 	function error(name:String, pos:Position) {
 		logPos('Anonymous structure "${name}" found, use "typedef"', pos);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "severity",
+				values: ["INFO"]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/type/DynamicCheck.hx

@@ -29,4 +29,14 @@ class DynamicCheck extends Check {
 	function error(name:String, pos:Position) {
 		logPos('"${name}" type is "Dynamic"', pos);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "severity",
+				values: ["INFO"]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/type/ReturnCheck.hx

@@ -114,4 +114,22 @@ class ReturnCheck extends Check {
 		}
 		else logPos('Return type not specified for method "${name}"', pos);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "allowEmptyReturn",
+				values: [true, false]
+			},
+			{
+				propertyName: "enforceReturnTypeForAnonymous",
+				values: [true, false]
+			},
+			{
+				propertyName: "enforceReturnType",
+				values: [true, false]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/whitespace/ArrayAccessCheck.hx

@@ -41,4 +41,18 @@ class ArrayAccessCheck extends Check {
 			lastExpr = e;
 		});
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [],
+			properties: [{
+				propertyName: "spaceBefore",
+				values: [true, false]
+			},
+			{
+				propertyName: "spaceInside",
+				values: [true, false]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/whitespace/EmptyLinesCheck.hx

@@ -94,4 +94,37 @@ class EmptyLinesCheck extends LineCheckBase {
 	function logInfo(pos) {
 		log('Too many consecutive empty lines (> ${max})', pos, 0);
 	}
+
+	override public function detectableInstances():DetectableInstances {
+		return [{
+			fixed: [{
+				propertyName: "max",
+				value: 1
+			}],
+			properties: [{
+				propertyName: "allowEmptyLineAfterSingleLineComment",
+				values: [false, true]
+			},
+			{
+				propertyName: "allowEmptyLineAfterMultiLineComment",
+				values: [false, true]
+			},
+			{
+				propertyName: "requireEmptyLineAfterPackage",
+				values: [true, false]
+			},
+			{
+				propertyName: "requireEmptyLineAfterClass",
+				values: [true, false]
+			},
+			{
+				propertyName: "requireEmptyLineAfterInterface",
+				values: [true, false]
+			},
+			{
+				propertyName: "requireEmptyLineAfterAbstract",
+				values: [true, false]
+			}]
+		}];
+	}
 }

src/checkstyle/checks/whitespace/IndentationCheck.hx

@@ -144,7 +144,7 @@ class IndentationCheck extends Check {
 	function calcLineIndentationBkOpen(token:TokenTree, lineIndentation:Array<Int>) {
 		var child:TokenTree = token.getFirstChild();
 		if (child == null) return;
-		if (child.is(BrOpen)) {
+		if ((child.is(BrOpen)) || (child.is(BkOpen))) {
 			// only indent once, if directly next to each other `[{`
 			if (token.pos.min + 1 == child.pos.min) return;
 		}
@@ -354,7 +354,7 @@ class IndentationCheck extends Check {
 			},
 			{
 				propertyName: "wrapPolicy",
-				values: [NONE, LARGER, EXACT]
+				values: [NONE, EXACT, LARGER]
 			}]
 		}];
 	}