basic spacing rules and such

.gitignore

@@ -19,4 +19,5 @@ _cgo_export.*
_testmain.go
*.exe
*.exe
csfmt

LICENSE

@@ -0,0 +1,8 @@
"THE BEER-WARE LICENSE" (Revision 42)
=====================================
[Bryan Allred](bryan@revolvingcow.com) wrote this file. As long as you retain this
notice you can do whatever you want with this stuff. If we meet some day, and you
think this stuff is worth it, you can buy me a beer in return.
Bryan Allred

main.go

@@ -0,0 +1,76 @@
package main
import (
	"bytes"
	"log"
	"os"
	"code.revolvingcow.com/revolvingcow/csfmt/rules"
)
func main() {
	sourceFiles := []SourceFile{}
	// Determine what files to format
	argc := len(os.Args)
	if argc < 2 {
		return
	} else if argc == 2 && os.Args[1] == "..." {
		// Walk the file structure from the current working directory
		cwd, err := os.Getwd()
		if err != nil {
			return
		}
		s := SourceFile{
			Path: cwd,
		}
		for sourceFile := range s.Walk() {
			sourceFiles = append(sourceFiles, sourceFile)
		}
	} else {
		// Assuming multiple files were given
		// for _, a := range os.Args[1:] {
		a := os.Args[1]
		s := SourceFile{
			Path: a,
		}
		if s.Exists() {
			if s.IsDir() {
				for sourceFile := range s.Walk() {
					sourceFiles = append(sourceFiles, sourceFile)
				}
			} else if s.IsDotNet() {
				sourceFiles = append(sourceFiles, s)
			}
		}
		// }
	}
	count := len(sourceFiles)
	modified := 0
	queuedRules := rules.EnabledRules()
	for _, s := range sourceFiles {
		contents, err := s.Read()
		if err != nil {
			log.Fatalln(err)
		}
		original := contents
		for _, rule := range queuedRules {
			contents = rule.Apply(contents)
		}
		if bytes.Compare(original, contents) != 0 {
			modified++
		}
		s.Write(contents)
		// fmt.Println(string(contents))
	}
	log.Printf("Modified %d of %d files using %d rules\n", modified, count, len(queuedRules))
}

rules/closingParenthesisMustBeSpacedCorrectly.go

@@ -0,0 +1,33 @@
package rules
import "regexp"
var closingParenthesisMustBeSpacedCorrectly = &Rule{
	Name:        "Closing parenthesis must be spaced correctly",
	Enabled:     true,
	Apply:       applyClosingParenthesisMustBeSpacedCorrectly,
	Description: ``,
}
func applyClosingParenthesisMustBeSpacedCorrectly(source []byte) []byte {
	spaceBetween := `([A-z]|=|\+|\-|\*|/|&|\||\^|\{)`
	// Remove leading spaces
	re := regexp.MustCompile(`([\S])(\t| )([\)])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	// Remove trailing spaces
	re = regexp.MustCompile(`([\)])(\t| )([\S])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	// Add space between operators and keywords
	re = regexp.MustCompile(`([\)])` + spaceBetween)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $2"))
	}
	return source
}

rules/closingParenthesisMustBeSpacedCorrectly_test.go

@@ -0,0 +1,26 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestClosingParenthesisMustBeSpacedCorrectly(t *testing.T) {
	input := []byte(`if (true ){}
if (true) {}
public void something(int i ) {}
switch (foo ){}
(2)+1`)
	expected := []byte(`if (true) {}
if (true) {}
public void something(int i) {}
switch (foo) {}
(2) +1`)
	actual := applyClosingParenthesisMustBeSpacedCorrectly(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/codeMustNotContainMultipleBlankLinesInARow.go

@@ -0,0 +1,18 @@
package rules
import "regexp"
var codeMustNotContainMultipleBlankLinesInARow = &Rule{
	Name:        "Code must not contain multiple blank lines in a row",
	Enabled:     true,
	Apply:       applyCodeMustNotContainMultipleBlankLinesInARow,
	Description: ``,
}
func applyCodeMustNotContainMultipleBlankLinesInARow(source []byte) []byte {
	re := regexp.MustCompile("(\n\n)+")
	for re.Match(source) {
		source = re.ReplaceAllLiteral(source, []byte("\n"))
	}
	return source
}

rules/codeMustNotContainMultipleBlankLinesInARow_test.go

@@ -0,0 +1,25 @@
package rules
import (
	"bytes"
	"testing"
)
func TestCodeMustNotContainMultipleBlankLinesInARow(t *testing.T) {
	input := []byte(`public void FunctionName(string s, int i)
{
	return s + i.ToString();
}`)
	expected := []byte(`public void FunctionName(string s, int i)
{
	return s + i.ToString();
}`)
	actual := applyCodeMustNotContainMultipleBlankLinesInARow(input)
	if !bytes.Equal(expected, actual) {
		t.Fail()
	}
}

rules/codeMustNotContainMultipleWhitespaceInARow.go

@@ -0,0 +1,18 @@
package rules
import "regexp"
var codeMustNotContainMultipleWhitespaceInARow = &Rule{
	Name:        "Code must not contain multiple whitespaces in a row",
	Enabled:     true,
	Apply:       applyCodeMustNotContainMultipleWhitespaceInARow,
	Description: `A violation of this rule occurs whenver the code contains a tab character.`,
}
func applyCodeMustNotContainMultipleWhitespaceInARow(source []byte) []byte {
	re := regexp.MustCompile(`(\S)[ ]{2,}(\S)`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $2"))
	}
	return source
}

rules/codeMustNotContainMultipleWhitespaceInARow_test.go

@@ -0,0 +1,20 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestCodeMustNotContainMultipleWhitespaceInARow(t *testing.T) {
	input := []byte(`
	if  (i  == 0)  {  }`)
	expected := []byte(`
	if (i == 0) { }`)
	actual := applyCodeMustNotContainMultipleWhitespaceInARow(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/colonsMustBeSpacedCorrectly.go

@@ -0,0 +1,12 @@
package rules
var colonsMustBeSpacedCorrectly = &Rule{
	Name:        "Colons must be spaced correctly",
	Enabled:     false,
	Apply:       applyColonsMustBeSpacedCorrectly,
	Description: ``,
}
func applyColonsMustBeSpacedCorrectly(source []byte) []byte {
	return source
}

rules/commasMustBeSpacedCorrectly.go

@@ -0,0 +1,31 @@
package rules
import "regexp"
var commasMustBeSpacedCorrectly = &Rule{
	Name:        "Commas must be spaced correctly",
	Enabled:     true,
	Apply:       applyCommasMustBeSpacedCorrectly,
	Description: ``,
}
func applyCommasMustBeSpacedCorrectly(source []byte) []byte {
	// Look for leading spaces
	re := regexp.MustCompile(`(\n)*[\s]+,`)
	for re.Match(source) {
		source = re.ReplaceAllLiteral(source, []byte(","))
	}
	// Add trailing spaces as necessary
	re = regexp.MustCompile(`(\S),(\w|\d)`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1, $2"))
	}
	// Look for too many trailing spaces
	re = regexp.MustCompile(`\,  `)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte(", "))
	}
	return source
}

rules/commasMustBeSpacedCorrectly_test.go

@@ -0,0 +1,35 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestCommasMustBeSpacedCorrectly(t *testing.T) {
	input := []byte(`public void FunctionName(string s ,int i
	, object x)
{
	int[] b = new [1,   3,4 ,5];
	var o = new {
		blah = "stomething",
		meh = 0,
		dude = true,
	};
}`)
	expected := []byte(`public void FunctionName(string s, int i, object x)
{
	int[] b = new [1, 3, 4, 5];
	var o = new {
		blah = "stomething",
		meh = 0,
		dude = true,
	};
}`)
	actual := applyCommasMustBeSpacedCorrectly(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/documentationLinesMustBeginWithSingleSpace.go

@@ -0,0 +1,18 @@
package rules
import "regexp"
var documentationLinesMustBeginWithSingleSpace = &Rule{
	Name:        "Documentation lines must begin with a single space",
	Enabled:     true,
	Apply:       applyDocumentationLinesMustBeginWithSingleSpace,
	Description: ``,
}
func applyDocumentationLinesMustBeginWithSingleSpace(source []byte) []byte {
	re := regexp.MustCompile(`([/]{3})(\S)`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $2"))
	}
	return source
}

rules/documentationLinesMustBeginWithSingleSpace_test.go

@@ -0,0 +1,26 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestDocumentationLineMustBeginWithSingleSpace(t *testing.T) {
	input := []byte(`///<summary>
///The summary.
///</summary>
/// <param name="foo">The foo.</param>
/// <returns>The bar.</returns>`)
	expected := []byte(`/// <summary>
/// The summary.
/// </summary>
/// <param name="foo">The foo.</param>
/// <returns>The bar.</returns>`)
	actual := applyDocumentationLinesMustBeginWithSingleSpace(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/openingParenthesisMustBeSpacedCorrectly.go

@@ -0,0 +1,33 @@
package rules
import "regexp"
var openingParenthesisMustBeSpacedCorrectly = &Rule{
	Name:        "Opening parenthesis must be spaced correctly",
	Enabled:     true,
	Apply:       applyOpeningParenthesisMustBeSpacedCorrectly,
	Description: ``,
}
func applyOpeningParenthesisMustBeSpacedCorrectly(source []byte) []byte {
	spaceBetween := `(if|while|for|switch|foreach|using|\+|\-|\*|/|&|\||\^|=)`
	// Remove leading spaces
	re := regexp.MustCompile(`([\S])(\t| )([\(])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	// Remove trailing spaces
	re = regexp.MustCompile(`([\(])(\t| )([\S])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	// Add space between operators and keywords
	re = regexp.MustCompile(spaceBetween + `([\(])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $2"))
	}
	return source
}

rules/openingParenthesisMustBeSpacedCorrectly_test.go

@@ -0,0 +1,28 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestOpeningParenthesisMustBeSpacedCorrectly(t *testing.T) {
	input := []byte(`if(true) {}
if (true) {}
public void something ( int i) {}
switch(foo) {}
1+(2)
if (`)
	expected := []byte(`if (true) {}
if (true) {}
public void something(int i) {}
switch (foo) {}
1+ (2)
if (`)
	actual := applyOpeningParenthesisMustBeSpacedCorrectly(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/preprocessorKeywordsMustNotBePrecededBySpace.go

@@ -0,0 +1,19 @@
package rules
import "regexp"
var preprocessorKeywordsMustNotBePrecededBySpace = &Rule{
	Name:        "Single line comments must begin with single space",
	Enabled:     true,
	Apply:       applyPreprocessorKeywordsMustNotBePrecededBySpace,
	Description: ``,
}
func applyPreprocessorKeywordsMustNotBePrecededBySpace(source []byte) []byte {
	keywords := `(if|else|elif|endif|define|undef|warning|error|line|region|endregion|pragma|pragma warning|pragma checksum)`
	re := regexp.MustCompile(`([#])(\t| )+` + keywords)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	return source
}

rules/preprocessorKeywordsMustNotBePrecededBySpace_test.go

@@ -0,0 +1,52 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestPreprocessorKeywordsMustNotBePrecededBySpace(t *testing.T) {
	input := []byte(`
# if
	// Something
# else
	// Something
# elif
	// Something
# endif
# define
# undef
# warning
# error
# line
# region
# endregion
# pragma
# pragma warning
# pragma checksum`)
	expected := []byte(`
#if
	// Something
#else
	// Something
#elif
	// Something
#endif
#define
#undef
#warning
#error
#line
#region
#endregion
#pragma
#pragma warning
#pragma checksum`)
	actual := applyPreprocessorKeywordsMustNotBePrecededBySpace(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/rules.go

@@ -0,0 +1,243 @@
package rules
// The basic ruleset comes from [StyleCop][1] with them toggled on or off
// based solely on the authors supreme opinion(s).
//
// [1]: http://www.stylecop.com/docs/StyleCop%20Rules.html
// Rule is a style rule to look for and apply within the source code.
type Rule struct {
	Name        string
	Description string
	Enabled     bool
	Apply       func(source []byte) []byte
}
// Documentation rules
var Documentation = []*Rule{
// elementsMustBeDocument,
// partialElementsMustBeDocumented,
// enumerationItemsMustBeDocumented,
// documentationMustContainValidXml,
// elementDocumentationMustHaveSummary,
// elementDocumentationMustHaveSummaryText,
// elementDocumenationMustNotHaveDefaultSummary,
// elementDocumentationMustBeSpelledCorrectly,
// partialElementDocumentationMustHaveSummary,
// partialElementDocumentationMustHaveSummaryText,
// propertyDocumentationMustHaveValue,
// propertyDocumentationMustHaveValueText,
// elementParametersMustBeDocumented,
// elementParameterDocumentationMustMatchElementParameters,
// elementParameterDocumentationMustDeclareParameterName,
// elementParameterDocumentationMustHaveText,
// elementReturnValueMustBeDocumented,
// elementReturnValueDocumentationMustHaveValue,
// voidReturnValueMustNotBeDocumented,
// genericTypeParametersMustBeDocumented,
// genericTypeParametersMustBeDocumentedPartialClass,
// genericTypeParameterDocumentationMustMatchTypeParameters,
// genericTypeParameterDocumentationMustDeclareParameterName,
// genericTypeParameterDocumentationMustHaveText,
// propertySummaryDocumentationMustMatchAccessors,
// propertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess,
// elementDocumentationMustNotBeCopiedAndPasted,
// singleLineCommentsMustNotUseDocumentationStyleSlashes,
// documentationTextMustNotBeEmpty,
// documentationTextMustBeginWithACapitalLetter,
// documentationTextMustEndWithAPeriod,
// documentationTextMustContainWhitespace,
// documentationTextMustMeetCharacterPercentage,
// documentationTextMustMeetMinimumCharacterLenght,
// fileMustHaveHeader,
// fileHeaderMustShowCopyright,
// fileHeaderMustHaveCopyrightText,
// fileHeaderCopyrightTextMustMatch,
// fileHeaderMustContainFileName,
// fileHeaderFileNameDocumentationMustMatchFileName,
// fileHeaderMustHaveSummary,
// fileHeaderMustHaveValidCompanyText,
// fileHeaderCompanyNameTextMustMatch,
// fileHeaderFileNameDocumentationMustMatchTypeName,
// constructorSummaryDocumentationMustBeginWithStandardText,
// deconstructorSummaryDocumentationMustBeginWithStandardText,
// documentationHeadersMustNotContainBlankLines,
// includedDocumentationFileDoesNotExist,
// includedDocumentationXPathDoesNotExist,
// includedNodeDoesNotContainValidFileAndPath,
// inheritDocMustBeUsedWithInheritingClass,
}
// Layout rules
var Layout = []*Rule{
	// curlyBracketsForMultiLineStatementsMustNotShareLine,
	// statementMustNotBeOnSingleLine,
	// elementMustNotBeOnSingleLine,
	// curlyBracketsMustNotBeOmitted,
	// allAccessorMustBeMultiLineOrSingleLine,
	// openingCurlyBracketsMustNotBeFollowedByBlankLine,
	// elementDocumentationHeadersMustNotBeFollowedByBlankLine,
	codeMustNotContainMultipleBlankLinesInARow,
	// closingCurlyBracketsMustNotBePrecededByBlankLine,
	// openingCurlyBracketsMustNotBePrecededByBlankLine,
	// chainedStatementBlocksMustNotBePrecededByBlankLine,
	// whileDoFooterMustNotBePrecededByBlankLine,
	// singleLineCommentsMustNotBeFollowedByBlankLine,
	// closingCurlyBracketMustBeFollowedByBlankLine,
	// elementDocumentationHeaderMustBePrecededByBlankLine,
	// singleLineCommentMustBePrecededByBlankLine,
	// elementsMustBeSeparatedByBlankLine,
	// codeMustNotContainBlankLinesAtStartOfFile,
	// codeMustNotContainBlankLinesAtEndOfFile,
}
// Maintainability Rules
var Maintainability = []*Rule{
// statementMustNotUseUnnecessaryParenthesis,
// accessModifierMustBeDeclared,
// fieldsMustBePrivate,
// fileMayOnlyContainASingleClass,
// fileMayOnlyContainASingleNamespace,
// codeAnalysisSuppressionMustHaveJustification,
// debugAssertMustProvideMessageText,
// debugFailMustProvideMessageText,
// arithmeticExpressionsMustDeclarePrecedence,
// conditionalExpressionsMustDeclarePrecendence,
// removeUnnecessaryCode,
// removeDelegateParenthesisWhenPossible,
// attributeConstructorMustNotUseUnnecessaryParenthesis,
}
// Naming Rules
var Naming = []*Rule{
// elementMustBeginWithUpperCaseLetter,
// elementMustBeginWithLowerCaseLetter,
// interfaceNamesMustBeginWithI,
// constFieldNamesMustBeginWithUpperCaseLetter,
// nonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter,
// fieldNamesMustNotUseHungarianNotation,
// fieldNamesMustBeginWithLowerCaseLetter,
// accessibleFieldsMustBeginWithUpperCaseLetter,
// variableNamesMustNotBePrefixed,
// fieldNamesMustNotBeginWithUnderscore,
// fieldNamesMustNotContainUnderscore,
// staticReadonlyFieldsMustBeginWithUpperCaseLetter,
}
// Ordering Rules
var Ordering = []*Rule{
	// usingDirectivesMustBePlacedWithinNamespace,
	// elementsMustAppearInTheCorrectOrder,
	// elementsMustBeOrderedByAccess,
	// constantsMustAppearBeforeFields,
	// staticElementsMustAppearBeforeInstanceElements,
	// partialElementsMustDeclareAccess,
	// declarationKeywordsMustFollowOrder,
	// protectedMustComeBeforeInternal,
	// systemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives,
	// usingAliasDirectivesMustBePlacedAfterOtherUsingDirectives,
	usingDirectivesMustBeOrderedAlphabeticallyByNamespace,
	// usingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName,
	// propertyAccessorsMustFollowOrder,
	// eventAccessorsMustFollowOrder,
	// staticReadonlyElementsMustAppearBeforeStaticNonReadonlyElements,
	// instanceReadonlyElementsMustAppearBeforeInstanceNonReadonlyElements,
}
// Readability Rules
var Readability = []*Rule{
// doNotPrefixCallsWithBaseUnlessLocalImplementationExists,
// prefixLocalCallsWithThis,
// queryClauseMustFollowPreviousClause,
// queryClausesMustBeOnSeparateLinesOrAllOnOneLine,
// queryClauseMustBeginOnNewLineWhenPreviousClauseSpansMultipleLines,
// queryClausesSpanningMultipleLinesMustBeginOnOwnLine,
// codeMustNotContainEmptyStatements,
// codeMustNotContainMultipleStatementsOnOneLine,
// blockStatementsMustNotContainEmbeddedComments,
// blockStatementsMustNotContainEmbeddedRegions,
// openingParenthesisMustBeOnDeclarationLine,
// closingParenthesisMustBeOnLineOfOpeningParenthesis,
// commaMustBeOnSameLineAsPreviousParameter,
// parameterListMustFollowDeclaration,
// parameterMustFollowComma,
// splitParametersMustStartOnLineAfterDeclaration,
// parametersMustBeOnSameLineOrSeparateLines,
// parametersMustNotSpanMultipleLines,
// commentsMustContainText,
// useBuiltInTypeAlias,
// useStringEmptyForEmptyStrings,
// doNotPlaceRegionsWithinElements,
// doNotUseRegions,
// useShorthandForNullableTypes,
// prefixCallsCorrectly,
}
// Spacing Rules
var Spacing = []*Rule{
	symbolsMustBeSpacedCorrectly,
	// keywordsMustBeSpacedCorrectly,
	commasMustBeSpacedCorrectly,
	semicolonsMustBeSpacedCorrectly,
	singleLineCommentsMustBeginWithSingleSpace,
	documentationLinesMustBeginWithSingleSpace,
	preprocessorKeywordsMustNotBePrecededBySpace,
	// operatorKeywordMustBeFollowedBySpace,
	openingParenthesisMustBeSpacedCorrectly,
	closingParenthesisMustBeSpacedCorrectly,
	// openingSquareBracketsMustBeSpacedCorrectly,
	// closingSquareBracketsMustBeSpacedCorrectly,
	// openingCurlyBracketsMustBeSpacedCorrectly,
	// closingCurlyBracketsMustBeSpacedCorrectly,
	// openingGenericBracketsMustBeSpacedCorrectly,
	// closingGenericBracketsMustBeSpacedCorrectly,
	// openingAttributeBracketsMustBeSpacedCorrectly,
	// closingAttributeBracketsMustBeSpacedCorrectly,
	// nullableTypeSymbolsMustNotBePrecededBySpace,
	// memberAccessSymbolsMustBeSpacedCorrectly,
	// incrementDecrementSymbolsMustBeSpacedCorrectly,
	// negativeSignsMustBeSpacedCorrectly,
	// positiveSignsMustBeSpacedCorrectly,
	// dereferenceAndAccessOfSymbolsMustBeSpacedCorrectly,
	colonsMustBeSpacedCorrectly,
	codeMustNotContainMultipleWhitespaceInARow,
	// codeMustNotContainSpaceAfterNewKeywordInImplicitlyTypedArrayAllocation,
	tabsMustNotBeUsed,
}
func EnabledRules() []*Rule {
	enabled := []*Rule{}
	for _, rule := range Documentation {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	for _, rule := range Layout {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	for _, rule := range Maintainability {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	for _, rule := range Ordering {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	for _, rule := range Readability {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	for _, rule := range Spacing {
		if rule.Enabled {
			enabled = append(enabled, rule)
		}
	}
	return enabled
}

rules/semicolonsMustBeSpacedCorrectly.go

@@ -0,0 +1,25 @@
package rules
import "regexp"
var semicolonsMustBeSpacedCorrectly = &Rule{
	Name:        "Semicolons must be spaced correctly",
	Enabled:     true,
	Apply:       applySemicolonsMustBeSpacedCorrectly,
	Description: ``,
}
func applySemicolonsMustBeSpacedCorrectly(source []byte) []byte {
	// Look for leading spaces
	re := regexp.MustCompile(`\s;`)
	for re.Match(source) {
		source = re.ReplaceAllLiteral(source, []byte(";"))
	}
	// Add trailing spaces as necessary
	re = regexp.MustCompile(`;(\S)`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("; $1"))
	}
	return source
}

rules/semicolonsMustBeSpacedCorrectly_test.go

@@ -0,0 +1,32 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestSemicolonsMustBeSpacedCorrectly(t *testing.T) {
	input := []byte(`public void FunctionName(string s, int i)
{
	var i = 0; // blah
	for (i = 0;i < 4;i++) {
		// Do something
	}
	return s + i.ToString() ;
}`)
	expected := []byte(`public void FunctionName(string s, int i)
{
	var i = 0; // blah
	for (i = 0; i < 4; i++) {
		// Do something
	}
	return s + i.ToString();
}`)
	actual := applySemicolonsMustBeSpacedCorrectly(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/singleLineCommentsMustBeginWithSingleSpace.go

@@ -0,0 +1,26 @@
package rules
import "regexp"
var singleLineCommentsMustBeginWithSingleSpace = &Rule{
	Name:        "Single line comments must begin with single space",
	Enabled:     true,
	Apply:       applySingleLineCommentsMustBeginWithSingleSpace,
	Description: ``,
}
func applySingleLineCommentsMustBeginWithSingleSpace(source []byte) []byte {
	re := regexp.MustCompile(`([/]{2})([\S])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $2"))
	}
	re = regexp.MustCompile(`([/]{2})([\s]{2,})([\S])`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1 $3"))
	}
	re = regexp.MustCompile(`([/]{2})([\s])([/]{1,})([\s]*)`)
	for re.Match(source) {
		source = re.ReplaceAll(source, []byte("$1$3"))
	}
	return source
}

rules/singleLineCommentsMustBeginWithSingleSpace_test.go

@@ -0,0 +1,26 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestSingleLineCommentsMustBeingWithSingleSpace(t *testing.T) {
	input := []byte(`//This is a comment with no space
//  This is a comment with too many spaces
////int i = 0;
//////int i = 0;
////return i;`)
	expected := []byte(`// This is a comment with no space
// This is a comment with too many spaces
////int i = 0;
//////int i = 0;
////return i;`)
	actual := applySingleLineCommentsMustBeginWithSingleSpace(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/symbolsMustBeSpacedCorrectly.go

@@ -0,0 +1,148 @@
package rules
import (
	"bufio"
	"bytes"
	"regexp"
)
var symbolsMustBeSpacedCorrectly = &Rule{
	Name:        "Symbols must be spaced correctly",
	Enabled:     true,
	Apply:       applySymbolsMustBeSpacedCorrectly,
	Description: ``,
}
func applySymbolsMustBeSpacedCorrectly(source []byte) []byte {
	reCommentShortBegin := regexp.MustCompile(`\A\s*(/{2,})`)
	reCommentLongBegin := regexp.MustCompile(`\A\s*(/\*)`)
	reCommentLongEnd := regexp.MustCompile(`\*/`)
	short := false
	long := false
	lines := []byte{}
	buffer := bytes.NewBuffer(source)
	scanner := bufio.NewScanner(buffer)
	for scanner.Scan() {
		// Add a newline character on each line after the first
		if len(lines) > 0 {
			lines = append(lines, byte('\n'))
		}
		line := scanner.Bytes()
		short = reCommentShortBegin.Match(line)
		long = long || reCommentLongBegin.Match(line)
		if !(short || long) {
			// Look for pairings
			re := regexp.MustCompile(`(\w?)([<>!\+\-\*\^%/\^=&\|]?[=\|&]|[<>])(\w?)`)
			line = re.ReplaceAll(line, []byte("$1 $2 $3"))
			// Incrementors and decrementors
			re = regexp.MustCompile(`([^\(])([\W])(\+\+|\-\-)(\w)`)
			line = re.ReplaceAll(line, []byte("$1$2 $3$4"))
			re = regexp.MustCompile(`(\w)(\+\+|\-\-)([^\)])`)
			line = re.ReplaceAll(line, []byte("$1$2 $3$4"))
			// // Singlets
			// re = regexp.MustCompile(`([\+\-\*/][^<>=\-\+\)]?)(\w)`)
			// line = re.ReplaceAll(line, []byte("$1 $2"))
			// re = regexp.MustCompile(`(\w)([\+\-\*/][^<>=\-\+\)]?)`)
			// line = re.ReplaceAll(line, []byte("$1 $2"))
			// Fix generics
			re = regexp.MustCompile(`( < )(.*)( >\s*)`)
			line = re.ReplaceAll(line, []byte("<$2>"))
		}
		short = false
		long = long && !reCommentLongEnd.Match(line)
		lines = append(lines, line...)
	}
	return lines
}
// func applySymbolsMustBeSpacedCorrectly(source []byte) []byte {
// 	alphaNumeric := `(\S)`
// 	symbols := `([|=|\+|\-|\*|/|\||&|\^|<|>|!|])`
// 	unary := `([!])`
//
// 	reCommentShortBegin := regexp.MustCompile(`\A\s*(/{2,})`)
// 	reCommentLongBegin := regexp.MustCompile(`\A\s*(/\*)`)
// 	reCommentLongEnd := regexp.MustCompile(`\*/`)
//
// 	short := false
// 	long := false
// 	lines := []byte{}
// 	buffer := bytes.NewBuffer(source)
// 	scanner := bufio.NewScanner(buffer)
// 	for scanner.Scan() {
// 		// Add a newline character on each line after the first
// 		if len(lines) > 0 {
// 			lines = append(lines, byte('\n'))
// 		}
//
// 		line := scanner.Bytes()
//
// 		short = reCommentShortBegin.Match(line)
// 		long = long || reCommentLongBegin.Match(line)
//
// 		if !(short || long) {
// 			// Break apart all the symbols
// 			re := regexp.MustCompile(alphaNumeric + symbols)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1 $2"))
// 			}
// 			re = regexp.MustCompile(symbols + alphaNumeric)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1 $2"))
// 			}
//
// 			// Fix basic spacing
// 			re = regexp.MustCompile(symbols + `([\s])` + symbols)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1$3"))
// 			}
//
// 			// Fix unary operators
// 			re = regexp.MustCompile(`([\S])([\s]*)` + unary + `([\s])([\S])`)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1 $3$5"))
// 			}
//
// 			// Fix generics
// 			re = regexp.MustCompile(`( < )(.*)( >\s*)`)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("<$2>"))
// 			}
//
// 			// Fix incrementer/decrementer
// 			re = regexp.MustCompile(`(--|\+\+)` + symbols)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1 $2"))
// 			}
// 			re = regexp.MustCompile(symbols + `(--|\+\+)`)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1 $2"))
// 			}
// 			re = regexp.MustCompile(`([A-z]|[\d]|[\(])([\s])(--|\+\+)`)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1$3"))
// 			}
// 			re = regexp.MustCompile(`(--|\+\+)([\s])([A-z]|[\d]|[\)])`)
// 			for re.Match(line) {
// 				line = re.ReplaceAll(line, []byte("$1$3"))
// 			}
//
// 			lines = append(lines, line...)
// 		} else {
// 			lines = append(lines, line...)
// 		}
//
// 		short = false
// 		long = long && !reCommentLongEnd.Match(line)
// 	}
//
// 	return lines
// }

rules/symbolsMustBeSpacedCorrectly_test.go

@@ -0,0 +1,56 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestSymbolsMustBeSpacedCorrectly(t *testing.T) {
	input := []byte(`/// <summary>
	int i=0;
	if (i==0) i+=2;
	if (i!=0) i-=2;
	if (i>0) i/=1;
	if (i<0) i*=1;
	// This is a comment
	if (i<=0) i++*0;
	/* This is another comment */
	if (i>=0)++i;
	/* <This is a comment>
	 *
	 */
	for (var i=1; i>-1; i--) {}
	if (i||i)--i;
	if (i&&i) i--*0;
	if (1+1==2) i-1+(i*3)/(i/1)
	a&&!b
	if!(true);
	as IEnumerable<Namespace.ClassName>`)
	expected := []byte(`/// <summary>
	int i = 0;
	if (i == 0) i += 2;
	if (i != 0) i -= 2;
	if (i > 0) i /= 1;
	if (i < 0) i *= 1;
	// This is a comment
	if (i <= 0) i++ * 0;
	/* This is another comment */
	if (i >= 0) ++i;
	/* <This is a comment>
	 *
	 */
	for (var i = 1; i > -1; i-- ) {}
	if (i || i) --i;
	if (i && i) i-- * 0;
	if (1 + 1 == 2) i - 1 + (i * 3) / (i / 1)
	a && !b
	if !(true);
	as IEnumerable<Namespace.ClassName>`)
	actual := applySymbolsMustBeSpacedCorrectly(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/tabsMustNotBeUsed.go

@@ -0,0 +1,18 @@
package rules
import "regexp"
var tabsMustNotBeUsed = &Rule{
	Name:        "Tabs must not be used",
	Enabled:     true,
	Apply:       applyTabsMustNotBeUsed,
	Description: `A violation of this rule occurs whenver the code contains a tab character.`,
}
func applyTabsMustNotBeUsed(source []byte) []byte {
	re := regexp.MustCompile(`\t`)
	for re.Match(source) {
		source = re.ReplaceAllLiteral(source, []byte("    "))
	}
	return source
}

rules/tabsMustNotBeUsed_test.go

@@ -0,0 +1,32 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestTabsMustNotBeUsed(t *testing.T) {
	input := []byte(`public void FunctionName(string s, int i)
{
	var i = 0; // blah
	for (i = 0; i < 4; i++) {
		// Do something
	}
	return s + i.ToString();
}`)
	expected := []byte(`public void FunctionName(string s, int i)
{
    var i = 0; // blah
    for (i = 0; i < 4; i++) {
        // Do something
    }
    return s + i.ToString();
}`)
	actual := applyTabsMustNotBeUsed(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

rules/usingDirectivesMustBeOrderedAlphabeticallyByNamespace.go

@@ -0,0 +1,70 @@
package rules
import (
	"bufio"
	"bytes"
	"fmt"
	"regexp"
	"sort"
	"strings"
)
var usingDirectivesMustBeOrderedAlphabeticallyByNamespace = &Rule{
	Name:        "Using directives must be ordered alphabetically by namespace",
	Enabled:     true,
	Apply:       applyUsingDirectivesMustBeOrderedAlphabeticallyByNamespace,
	Description: ``,
}
func applyUsingDirectivesMustBeOrderedAlphabeticallyByNamespace(source []byte) []byte {
	reCommentShortBegin := regexp.MustCompile(`\A\s*(/{2,})`)
	reCommentLongBegin := regexp.MustCompile(`\A\s*(/\*)`)
	reCommentLongEnd := regexp.MustCompile(`\*/`)
	short := false
	long := false
	skipNewline := false
	lines := []byte{}
	usings := []string{}
	buffer := bytes.NewBuffer(source)
	scanner := bufio.NewScanner(buffer)
	for scanner.Scan() {
		// Add a newline character on each line after the first
		if len(lines) > 0 && !skipNewline {
			lines = append(lines, byte('\n'))
		}
		skipNewline = false
		line := scanner.Bytes()
		short = reCommentShortBegin.Match(line)
		long = long || reCommentLongBegin.Match(line)
		if !(short || long) {
			// Find usings
			re := regexp.MustCompile(`(.*)(using)([\t| ])([^\(])(.*)([;])`)
			if re.Match(line) {
				using := re.ReplaceAll(line, []byte("$2 $4$5"))
				usings = append(usings, string(using))
				skipNewline = true
				line = []byte{}
			}
		}
		short = false
		long = long && !reCommentLongEnd.Match(line)
		lines = append(lines, line...)
	}
	if len(usings) > 0 {
		// Sort the usings and add them to the top of the file
		s := sort.StringSlice(usings)
		if !sort.IsSorted(s) {
			sort.Sort(s)
		}
		lines = append([]byte(fmt.Sprintf("%s;\n\n", strings.Join(s, ";\n"))), lines...)
	}
	return lines
}

rules/usingDirectivesMustBeOrderedAlphabeticallyByNamespace_test.go

@@ -0,0 +1,55 @@
package rules
import (
	"bytes"
	"fmt"
	"testing"
)
func TestUsingDirectivesMustBeOrderedAlphabeticallyByNamespace(t *testing.T) {
	input := []byte(`using Company;
using CompanyB.System;
using Company.Collections.Generic;
using Company.Linq;
namespace Company.Blah {}
using (var something = new Something()) {}`)
	expected := []byte(`using Company;
using Company.Collections.Generic;
using Company.Linq;
using CompanyB.System;
namespace Company.Blah {}
using (var something = new Something()) {}`)
	actual := applyUsingDirectivesMustBeOrderedAlphabeticallyByNamespace(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
	input = []byte(`using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Services;
using System.Web.UI;
using Usar.Eks.ProjDoc.Concrete;
using Usar.Eks.ProjDoc.Extensions;
namespace Company.Blah {}`)
	expected = []byte(`using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Services;
using System.Web.UI;
using Usar.Eks.ProjDoc.Concrete;
using Usar.Eks.ProjDoc.Extensions;
namespace Company.Blah {}`)
	actual = applyUsingDirectivesMustBeOrderedAlphabeticallyByNamespace(input)
	if !bytes.Equal(expected, actual) {
		fmt.Println(string(actual))
		t.Fail()
	}
}

sourceFile.go

@@ -0,0 +1,93 @@
package main
import (
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
)
var (
	extensions = [...]string{".cs"}
)
// SourceFile represents a file declared as source code.
type SourceFile struct {
	Path string
}
func (f *SourceFile) Exists() bool {
	if _, err := os.Stat(f.Path); os.IsNotExist(err) {
		return false
	}
	return true
}
func (f *SourceFile) IsDir() bool {
	fi, err := os.Stat(f.Path)
	if err != nil {
		return false
	}
	return fi.IsDir()
}
func (f *SourceFile) IsDotNet() bool {
	name := strings.ToLower(f.Path)
	for _, extension := range extensions {
		if strings.HasSuffix(name, extension) {
			return true
		}
	}
	return false
}
// Read the file contents.
func (f *SourceFile) Read() ([]byte, error) {
	contents, err := ioutil.ReadFile(f.Path)
	if err != nil {
		return nil, err
	}
	return contents, nil
}
// Write the contents out to a stream.
func (f *SourceFile) Write(contents []byte) error {
	fi, err := os.OpenFile(f.Path, os.O_TRUNC|os.O_WRONLY, 0666)
	if err != nil {
		return err
	}
	defer fi.Close()
	_, err = fi.Write(contents)
	if err != nil {
		return err
	}
	return nil
}
// Walk a directory's file structure looking for source files.
func (f *SourceFile) Walk() chan SourceFile {
	c := make(chan SourceFile)
	go func() {
		filepath.Walk(f.Path, func(p string, fi os.FileInfo, e error) error {
			if e != nil {
				return e
			}
			s := SourceFile{
				Path: p,
			}
			if s.IsDotNet() {
				c <- s
			}
			return nil
		})
		defer close(c)
	}()
	return c
}