sleekbyte/tailor

Cross-platform static analyzer and linter for Swift.

tailor's Issues

Create contribution guidelines

Validate Java source automatically against Checkstyle, FindBugs, and PMD

Checkstyle

• The Checkstyle Plugin
• apply plugin: 'checkstyle'

FindBugs

• The FindBugs Plugin
• apply plugin: 'findbugs'

PMD

• The PMD Plugin
• apply plugin: 'pmd'

Restrict redundant parentheses

Do not use parentheses around:

• control flow constructs
  • for
  • while
  • repeat while
  • if
  • switch
  • guard
• exception handling constructs
  • throw
  • catch
• collections
  • array items
  • dictionary items
• initializer

Enforce lowerCamelCase naming convention

The following constructs should be named using the lowerCamelCase format:

• method and selector names

func someMethod() {
    // method definition goes here
}

• variable names

var someVariable = someValue

Restrict number of lines per file and method

Allow user to set a maximum line count restriction in

• file
• class/closure/function/struct

By default, the user will be allowed to create files and methods with infinite number of lines.

Enforce absence of spaces

No spaces:

• between parentheses and content
• between angle brackets and content
• between function name and parameter list
• [ ] around unary operands

Decrease default message classifications to warning, make levels customizable via flag

Potentially also add an option to use the "note" message style. These will not show up in the editor window, but will be displayed in the Build Log under "All Messages".

Add functional tests for argument parsing

Test cases:

• Zero file arguments
• One file argument
• Multiple file arguments
• Options (flags)
• Usage/help

Buffer output in printer class and remove duplicate error messages

• Buffer output and remove duplicates
• Complete // TODO: Use == once #33 "Buffer output in printer class and remove duplicate error messages" is complete

Detect lexer/parser errors and abort rule analysis

The ANTLR API does not seem to throw any exceptions but rather just print to STDERR, this output could be captured and tested for emptiness to detect errors and abort walking the partial tree or invoking the FileListener.

Alternatively, investigate use of ANTLRErrorStrategy along with Parser.notifyErrorListeners(java.lang.String) and/or reportError(Parser recognizer, RecognitionException e) to report any kind of RecognitionException.

Migrate string literals to resources file

e.g. constants.py based on Constant String File in Python

Enforce spacing in inheritance/protocol lists

• Separate protocol adoption list by “, ”

Sort Printer output by line and column

Sort the set of messages output by Printer with line as primary sort and column as secondary sort. Dependent on #33.

Automate process of building lexer and parser from grammar

Steps to automate:

• run antlr4 on modified grammar
• remove *.token files
• rename parser files to match python filename convention
• change any references inside generated files to match file name changes
• move files to tailor/swift

Update branch naming and PR review flow in contribution guidelines

Enforce TODO comment syntax

Ensure TODO comments are defined as follows in single line comments //:

• Without developer name

// TODO: <insert mandatory todo comment>

• With developer name

// TODO(dev-name): <insert mandatory todo comment>

Note: Nested single line comments will be analyzed and flagged.

Modify Location and Printer to support specifying a line without a particular column

Xcode will point to a specific character if both line and column are specified, but this doesn't always make sense for some rules (e.g. file too long). Modify logic in Location and Printer classes to support column parameter being optional.

• Support optional column parameter
• Complete // TODO: #33: Use printer method where column is unspecified

Refactor functional tests

Set up continuous integration via Travis

Create script to generate a visual parse tree for specified Swift source code

Allow enabling/disabling each rule individually via flags

This will also help in isolating functional tests to specific features, tests should be modified to use these flags once implemented.

For example (based on Pylint):
--enable=semicolon,uppercamelcase,lowercamelcase,kprefix (whitelist)
AND
--disable=semicolon,redundantparens,closureparens (blacklist)

Add code snippets from the Swift Language Guide

• Add code snippets obtained from the various sections in the Swift Language Guide
• Add a test to run the parser on each file and ensure that there are no parsing errors

Enforce UpperCamelCase naming convention

The following constructs should be named using the UpperCamelCase format:

• class names

class SomeClass {
    // class definition goes here
}

• enumeration types

enum SomeEnumeration {
    // enumeration definition goes here
}

• enumeration values

enum CompassPoint {
    case North
    case South
    case East
    case West
}

• struct names

struct SomeStructure {
    // structure definition goes here
}

• protocol names

protocol SomeProtocol {
    // protocol definition goes here
}

Port Python code to Java

• Organize directory structure/packages
• Port script
  • Use Java runtime for ANTLR
  • Add dependencies to bootstrap/build script
  • Set up pre-commit hooks
• Port main
• Relocate ANTLR output
• Port listeners and utils
  • UpperCamelCase rule
  • Semicolon rule
  • Constant naming convention rule
  • Construct length rule (vertical, i.e. num lines)
  • Line/identifier length rule (horizontal, i.e. num characters)
• Port output
• Port unit and functional tests
• Javadocs, resolve #26

Enforce minimum limits for variable/constant names

Avoid single letter variable/constant names except in for loops

Enforce Ternary expression conditions to be enclosed in parentheses

Preferred:

let rowHeight = contentHeight + ((hasHeader == true) ? 50 : 20)

Not Preferred:

let rowHeight = contentHeight + (hasHeader == true ? 50 : 20)

Avoid using "k" prefix for constants

Preferred

let MaxHeight = 666

Not Preferred

let kMaxHeight = 666

Create project wiki

The project wiki should:

• specify development environment constraint
• provide link to contribution guidelines
• provide link to implemented features
• list and link to external tools/frameworks along with their licenses that are being used in the project

Add docstrings to all significant modules, classes, methods, and functions

These docstrings will be verified by pylint and pep257 in pre-commit hooks, however short functions/classes and tests may be exempt

Enforce indentation style

One of:

• 4 spaces, no tabs
• tabs, not spaces
• 2 spaces (reasoning: to conserve space and prevent line wrapping)

Support multiple source files as input

Multiple positional command line arguments should be supported, each of which is a Swift source file to be analyzed. This includes shell glob expansion.

Enforce maximum item/construct limits

• Number of functions per class/file
• Number of constants per file
• Number of local variables in a class/function
• Number of parameters that a method/function takes

Fix "for loop" grammar

Upgrade grammar to Swift 2.0

Swift 2.0

New language features to support:

• replace guard-clause with where-clause
• update conditions for while, if and guard statements
• repeat-while loops
• guard statements
• availability conditions
• throw statements
• try operator
• do-catch statements
• defer statements

Add pre-push hook to run CI script locally

Omit parentheses if function takes a single closure argument

Preferred:

someFunctionThatTakesAClosure {
    // trailing closure's body goes here
}

Not Preferred:

someFunctionThatTakesAClosure() {
    // trailing closure's body goes here
}

Example:

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map {
    (var number) -> String in
    var output = ""
    while number > 0 {
        output = digitNames[number % 10]! + output
        number /= 10
    }
    return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]

Add configurable constraints to set maximum line and variable/constant name lengths

By default, the max line length and max variable/constant name lengths will be infinite.

Restrict name lengths of:

• class
• enum
• enumcase
• struct
• protocol
• element
• function
• label
• setter
• typealias
• type
• variable
• constant

Automate development environment setup via bootstrap script

Fix grammar for attributes

The Swift Programming Language: Attributes

Column number specified by printer off by one

The printer counts column numbers from 0 instead of 1. This leads to inaccurate error/warning messages.

Example
If the error message is on line 1 and column 4, then the printer will claim that the error is on line 1 and column 3.

List import statements on separate lines

Preferred:

import Foundation
import Cocoa

Not Preferred:

import Foundation; import Cocoa

Create functional test harness

The functional test harness will diff the generated output from STDOUT against the expected functional test output *Tests.out.

Enforce naming convention for global and local constants

Users should be given a choice to use lowerCamelCase or UpperCamelCase to name global constants.

• global
  • lowerCamelCase
  • UpperCamelCase

Users are suggested to use lowerCamelCase names for local constants.

• local
  • lowerCamelCase

Fix grammar for setter declarations

The Swift Programming Language: Declarations

Enforce bracket styles (Part 1)

Related issues: #96, #100, #132, #135

Open brace should be on same line as statement

• class

class SomeClass: SomeSuperClass {
}

class Demo {
}

• function

func someMethod() {
}

• conditional

if someCondition {
}

else if someCondition {
}

else {
}

switch someCase {
  default:
      break
}

• loops

for var x = 0; x < 10; x+=1 {
}

for ; ; {
}

for var x ; ; {
}

for ; x ; {
}

for ; ; x {
}

for var x; x ; {
}

for var x; ; x {
}

for ; x ; x {
}

while someCondition {
}

repeat {
} while someCondition

for someElement in someCollection {
}

• initializer

init(length:Double, breadth:Double) {
   self.length = length
   self.breadth = breadth
}

• struct

struct DemoStruct : SomeParentStruct {
}

struct DemoStruct {
}

Set up pre-commit hook for lint and tests

Enforce whitespace checks

• one blank line between methods
• whitespace around operators when defining them

Preferred

prefix operator += {}

Not Preferred

prefix operator   +-+ {}
prefix operator **    {}

• only one space between opening construct and { brace (except for compound assignment operators +=)

Preferred

func helloWorld {
 // do something
}

Not Preferred

func helloWorld{
    // do something
}

class hello     {
    var message: String
}

• one space after // in comments

Preferred

// this is a comment

Not Preferred

//this is a comment

• start and end multi-line comments with a single space

Preferred

/* This is a
multiline comment */

Not Preferred

/*This is a
multiline comment*/

• Colon directly after identifier, then space and type name

Preferred

var x: Int = 2

Not Preferred

var x : Int
var y:   String

• Colon directly after key type, then space and value for dictionary types

Preferred

var x = [ 'key1': 1, 'key2': 2 ]
var y: [ Int: String ]

Not Preferred

var x = [ 'key1' : 1, 'key2':  3]
var y: [ Int :    String ]

• Colon directly after case label, then space and statements

Preferred

switch character {
case "a": doSomething(a);
default: alert();
}

Not Preferred

switch character {
case "a" : doSomething(a);
default:     alert();
}

• Colon directly after class/struct/protocol/extension name, followed by space, followed by type inheritance list

Preferred

class ClassName: BaseClass {
}

struct StructName: BaseStruct {
}

protocol ProtocolName: AnotherProtocol {
}

extension TypeName: ProtocolName {
}

Not Preferred

class ClassName : BaseClass {
}

struct StructName:  BaseStruct {
}

protocol ProtocolName:AnotherProtocol {
}

extension TypeName : ProtocolName {
}

• Single space before and after colon in a conditional expression

Preferred

var x = condition ? a : b

Not Preferred

var x = condition ? a: b
var x = condition ? a   : b

• Tuple name, followed by colon, followed by a space, followed by value

Preferred

var y = (key: 1, value: 2)

Not Preferred

var y = (key:1, value : 2)

• Colon directly after typeName, followed by a space in generic parameter clauses

Preferred

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
}

Not Preferred

func someFunction<T : SomeClass, U:SomeProtocol>(someT: T, someU: U) {
}

• Check for a space before and after '->' in function and closure declarations
• Check for a space before and after '->' in subscripts
• Check for a space before and after '->' in function types

Prevent semicolon (;) terminated statements

Preferred:

let swift = "compiled language"

Not Preferred:

let swift = "compiled language";

Encapsulate code for displaying output

Create a printer module (printer.py) with basic print functions for different severity levels.

Ensure that swift source files end with a newline character