Fix #132

README.md

@@ -83,10 +83,11 @@ you do not want to use the one created by the "--defaultConfig" option.
 * Variables that could have been declared const or immutable (experimental)
 * Redundant parenthesis.
 * Unused labels.
+* Lines longer than 120 characters.
 
 #### Wishlist
 
-[See this list of open issues](https://github.com/Hackerpilot/Dscanner/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement) for the wishlist. 
+[See this list of open issues](https://github.com/Hackerpilot/Dscanner/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement) for the wishlist.
 
 ### Reports
 The "--report" option writes a JSON report on the static analysis checks

src/analysis/config.d

@@ -98,4 +98,7 @@ struct StaticAnalysisConfig
 
 	@INI("Checks for labels with the same name as variables")
 	bool label_var_same_name_check;
+
+	@INI("Checks for lines longer than 120 characters")
+	bool long_line_check;
 }

src/analysis/helpers.d

@@ -53,16 +53,17 @@ S after(S)(S value, S separator)
 void assertAnalyzerWarnings(string code, const StaticAnalysisConfig config, string file=__FILE__, size_t line=__LINE__)
 {
 	import analysis.run : ParseAllocator, parseModule;
-	import dparse.lexer : StringCache;
+	import dparse.lexer : StringCache, Token;
 
 	StringCache cache = StringCache(StringCache.defaultBucketCount);
 	ParseAllocator p = new ParseAllocator;
-	const(Module) m = parseModule(file, cast(ubyte[]) code, p, cache, false);
+	const(Token)[] tokens;
+	const(Module) m = parseModule(file, cast(ubyte[]) code, p, cache, false, tokens);
 
 	auto moduleCache = ModuleCache(p);
 
 	// Run the code and get any warnings
-	MessageSet rawWarnings = analyze("test", m, config, moduleCache);
+	MessageSet rawWarnings = analyze("test", m, config, moduleCache, tokens);
 	string[] codeLines = code.split("\n");
 
 	// Get the warnings ordered by line

src/analysis/line_length.d

@@ -0,0 +1,47 @@
+//          Copyright Brian Schott (Hackerpilot) 2015.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+module analysis.line_length;
+
+import dparse.lexer;
+import dparse.ast;
+import analysis.base : BaseAnalyzer;
+
+/**
+ * Checks for lines longer than 120 characters
+ */
+class LineLengthCheck : BaseAnalyzer
+{
+	///
+	this(string fileName, const(Token)[] tokens)
+	{
+		super(fileName, null);
+		this.tokens = tokens;
+	}
+
+	override void visit(const Module)
+	{
+		ulong lastErrorLine = ulong.max;
+		foreach (token; tokens)
+		{
+			if (token.column + token.text.length > MAX_LINE_LENGTH && token.line != lastErrorLine)
+			{
+				addErrorMessage(token.line, token.column, KEY, MESSAGE);
+				lastErrorLine = token.line;
+			}
+		}
+	}
+
+	alias visit = BaseAnalyzer.visit;
+
+private:
+
+	import std.conv : to;
+
+	enum string KEY = "dscanner.style.long_line";
+	enum string MESSAGE = "Line is longer than " ~ to!string(MAX_LINE_LENGTH) ~ " characters";
+	enum MAX_LINE_LENGTH = 120;
+	const(Token)[] tokens;
+}

src/analysis/run.d

@@ -51,6 +51,7 @@ import analysis.if_statements;
 import analysis.redundant_parens;
 import analysis.mismatched_args;
 import analysis.label_var_same_name_check;
+import analysis.line_length;
 
 import dsymbol.string_interning : internString;
 import dsymbol.scope_;
@@ -114,9 +115,10 @@ void generateReport(string[] fileNames, const StaticAnalysisConfig config,
 		auto code = uninitializedArray!(ubyte[])(to!size_t(f.size));
 		f.rawRead(code);
 		ParseAllocator p = new ParseAllocator;
-		const Module m = parseModule(fileName, code, p, cache, true, &lineOfCodeCount);
+		const(Token)[] tokens;
+		const Module m = parseModule(fileName, code, p, cache, true, tokens, &lineOfCodeCount);
 		stats.visit(m);
-		MessageSet results = analyze(fileName, m, config, moduleCache, true);
+		MessageSet results = analyze(fileName, m, config, moduleCache, tokens, true);
 		foreach (result; results[])
 		{
 			writeJSON(result.key, result.fileName, result.line, result.column, result.message);
@@ -154,12 +156,13 @@ bool analyze(string[] fileNames, const StaticAnalysisConfig config,
 		ParseAllocator p = new ParseAllocator;
 		uint errorCount = 0;
 		uint warningCount = 0;
-		const Module m = parseModule(fileName, code, p, cache, false, null,
+		const(Token)[] tokens;
+		const Module m = parseModule(fileName, code, p, cache, false, tokens, null,
 			&errorCount, &warningCount);
 		assert(m);
 		if (errorCount > 0 || (staticAnalyze && warningCount > 0))
 			hasErrors = true;
-		MessageSet results = analyze(fileName, m, config, moduleCache, staticAnalyze);
+		MessageSet results = analyze(fileName, m, config, moduleCache, tokens, staticAnalyze);
 		if (results is null)
 			continue;
 		foreach (result; results[])
@@ -170,15 +173,15 @@ bool analyze(string[] fileNames, const StaticAnalysisConfig config,
 }
 
 const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p,
-	ref StringCache cache, bool report, ulong* linesOfCode = null,
+	ref StringCache cache, bool report, ref const(Token)[] tokens,
-	uint* errorCount = null, uint* warningCount = null)
+	ulong* linesOfCode = null, uint* errorCount = null, uint* warningCount = null)
 {
 	import stats : isLineOfCode;
 
 	LexerConfig config;
 	config.fileName = fileName;
 	config.stringBehavior = StringBehavior.source;
-	const(Token)[] tokens = getTokensForParser(code, config, &cache);
+	tokens = getTokensForParser(code, config, &cache);
 	if (linesOfCode !is null)
 		(*linesOfCode) += count!(a => isLineOfCode(a.type))(tokens);
 	return dparse.parser.parseModule(tokens, fileName, p,
@@ -186,7 +189,8 @@ const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p,
 }
 
 MessageSet analyze(string fileName, const Module m,
-	const StaticAnalysisConfig analysisConfig, ref ModuleCache moduleCache, bool staticAnalyze = true)
+	const StaticAnalysisConfig analysisConfig, ref ModuleCache moduleCache,
+	const(Token)[] tokens, bool staticAnalyze = true)
 {
 	if (!staticAnalyze)
 		return null;
@@ -254,6 +258,8 @@ MessageSet analyze(string fileName, const Module m,
 		checks ~= new UnusedLabelCheck(fileName, moduleScope);
 	if (analysisConfig.unused_variable_check)
 		checks ~= new UnusedVariableCheck(fileName, moduleScope);
+	if (analysisConfig.long_line_check)
+		checks ~= new LineLengthCheck(fileName, tokens);
 	version (none)
 		if (analysisConfig.redundant_if_check)
 			checks ~= new IfStatementCheck(fileName, moduleScope);