indent: Fix several issues related to indentation

This addresses several issues regarding indentation.

1. Being able to indent conditional if/else assignments to make them
look more pleasing.

Most users wanted to do something like this

```cs
y = if a
      true
    else
      false
```

This now won't return an error for the user.

Fixes #468, #345

2. Fixed some bugs around chaining (.) operations

There were some cases of chaining operators not being evaluated
correctly. One was due to not checking for end tokens with `newLine`
properties.

Fixes #469, #348

3. Better cleanup of indented multi-line conditional statements.

Just some cleanup of the logic for the conditional in an if statement.

4. Empty if conditionals now do not generate indent message

While I think more often than not you should never need to have an empty
if conditional in your code. I do recognize it probably will happen, and
someone who chooses to use one should not be punished for it with an
indentation issue.

Closes #312

src/rules/indentation.coffee

@@ -24,6 +24,13 @@ module.exports = class Indentation

    tokens: ['INDENT', '[', ']', '.']

    keywords: [
      '->', '=>', '@', 'CATCH', 'CLASS', 'ELSE', 'FINALLY', 'FOR',
      'FORIN', 'FOROF', 'IDENTIFIER', 'IF', 'LEADING_WHEN', 'LOOP',
      'RETURN', 'SWITCH', 'THROW', 'TRY', 'UNTIL', 'WHEN', 'WHILE',
      'YIELD'
    ]

    constructor: ->
        @arrayTokens = []   # A stack tracking the array token pairs.

@@ -82,8 +89,8 @@ module.exports = class Indentation
        numIndents = @getCorrectIndent(tokenApi)

        # Now check the indentation.
        if not ignoreIndent and numIndents isnt expected
            return { context: "Expected #{expected} got #{numIndents}" }
        if not ignoreIndent and not (expected in numIndents)
            return { context: "Expected #{expected} got #{numIndents[0]}" }

    # Return true if the current token is inside of an array.
    inArray: () ->
@@ -111,8 +118,10 @@ module.exports = class Indentation
        # Traverse up the token list until we see a CALL_START token.
        # Don't scan above this line
        findCallStart = tokenApi.peek(-callStart)
        while (findCallStart and findCallStart[0] isnt 'TERMINATOR')
        while (findCallStart and (findCallStart[0] isnt 'TERMINATOR' or
                not findCallStart.newLine?))
            { first_line: lastCheck } = findCallStart[2]

            callStart += 1
            findCallStart = tokenApi.peek(-callStart)

@@ -147,20 +156,117 @@ module.exports = class Indentation
                if numIndents % expected isnt 0
                    return { context: "Expected #{expected} got #{numIndents}" }

    grabLineTokens: (tokenApi, lineNumber, all = false) ->
        { tokensByLine } = tokenApi
        lineNumber-- until tokensByLine[lineNumber]? or lineNumber is 0

        if all
            (tok for tok in tokensByLine[lineNumber])
        else
            (tok for tok in tokensByLine[lineNumber] when not
                tok.generated? and tok[0] isnt 'OUTDENT')

    # Returns a corrected INDENT value if the current line is part of
    # a chained call. Otherwise returns original INDENT value.
    getCorrectIndent: (tokenApi) ->
        { lineNumber, lines, tokens, i } = tokenApi
        { lineNumber, lines, tokens } = tokenApi

        curIndent = lines[lineNumber].match(/\S/)?.index

        prevNum = 1
        prevNum += 1 while (/^\s*(#|$)/.test(lines[lineNumber - prevNum]))

        prevLine = lines[lineNumber - prevNum]
        prevIndent = prevLine.match(/^(\s*)\./)?[1].length

        if prevIndent > 0
            return curIndent - prevLine.match(/\S/)?.index
        prevTokens = @grabLineTokens tokenApi, lineNumber - prevNum

        if prevTokens[0]?[0] is 'INDENT'
            # Pass both the INDENT value and the location of the first token
            # after the INDENT because sometimes CoffeeScript doesn't return
            # the correct INDENT if there is something like an if/else
            # inside an if/else inside of a -> function definition: e.g.
            #
            # ->
            #   r = if a
            #     if b
            #       2
            #     else
            #       3
            #   else
            #     4
            #
            # will error without: curIndent - prevTokens[1]?[2].first_column

            return [curIndent - prevTokens[1]?[2].first_column,
                curIndent - prevTokens[0][1]]
        else
            return tokens[i][1]
            prevIndent = prevTokens[0]?[2].first_column
            # This is a scan to handle extra indentation from if/else
            # statements to make them look nicer: e.g.
            #
            # r = if a
            #   true
            # else
            #   false
            #
            # is valid.
            #
            # r = if a
            #       true
            #     else
            #       false
            #
            # is also valid.
            for _, j in prevTokens when prevTokens[j][0] is '=' and
                    prevTokens[j + 1]?[0] is 'IF'
                skipAssign = curIndent - prevTokens[j + 1][2].first_column
                ret = curIndent - prevIndent
                return [ret] if skipAssign < 0
                return [skipAssign, ret]

            # This happens when there is an extra indent to maintain long
            # conditional statements (IF/UNLESS): e.g.
            #
            # ->
            #   if a is c and
            #     (false or
            #       long.expression.that.necessitates(linebreak))
            #     @foo()
            #
            # is valid (note that there an only an extra indent in the last
            # statement is required and not the line above it
            #
            # ->
            #   if a is c and
            #       (false or
            #       long.expression.that.necessitates(linebreak))
            #     @foo()
            # is also OK.
            while prevIndent > curIndent
                tryLine = lineNumber - prevNum
                prevTokens = @grabLineTokens tokenApi, tryLine, true

                # This is to handle weird object/string indentation.
                # See: 'Handle edge-case weirdness with strings in objects'
                #   test case in test_indentation.coffee or in the file,
                #   test_no_empty_functions.coffee, which is why/how I
                #   caught this.
                if prevTokens[0]?[0] is 'INDENT'
                    prevIndent = prevTokens[0][1]
                    prevTokens = prevTokens[1..]

                t = 0
                # keep looping prevTokens until we find a token in @keywords
                # or we just run out of tokens in prevTokens
                until not prevTokens[t]? or prevTokens[t][0] in @keywords
                    t++

                # slice off everything before 't'
                prevTokens = prevTokens[t..]
                prevNum++

                # if there isn't a valid token, restart the while loop
                continue unless prevTokens[0]?

                # set new "prevIndent"
                prevIndent = prevTokens[0]?[2].first_column

        return [curIndent - prevIndent]

test/test_indentation.coffee

@@ -128,13 +128,7 @@ vows.describe('indent').addBatch({

        'is ignored. Issue #4' : (source) ->
            errors = coffeelint.lint(source)
            errors = coffeelint.lint(source)
            assert.equal(errors.length, 1)
            error = errors[0]

            assert.equal(error.rule, 'indentation')
            assert.equal(error.lineNumber, 7)
            assert.equal(error.context, 'Expected 2 got 10')
            assert.isEmpty(errors)

    'Consecutive indented chained invocations' :

@@ -403,6 +397,7 @@ vows.describe('indent').addBatch({
        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    'Make sure indentation check is not affected outside proper scope' :
        topic : """
            a
@@ -421,4 +416,129 @@ vows.describe('indent').addBatch({
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    'Handle edge-case weirdness with strings in objects':
        # see test_no_empty_functions to understand why i needed to add this
        # and to add the code to handle it
        topic:
            '''
            call(
              "aaaaaaaaaaaaaaaaaaaaaaaaaaa
              bbbbbbbbbbbbbbbbbbbbbbb"      : first(
                'x = (@y) ->')
            )
            '''

        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    # Fixes people wanted to heavily indent if statements attached to assignment
    # See: #468, #345
    'Handle different if statements indentations' :
        topic : '''
            r = unless p1
              if p2
                1
              else
                2
            else
              3

            s = unless p1
                  if p2
                    1
                  else
                    2
                else
                  3

            t =
              if z
                true
              else
                true

            u = if p1
                  if p2
                    1
                  else
                    2
                else
                  3

            ->
              x = unless y1
                if y2
                  1
                else
                  y2
              else
                3
        '''

        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    # See #469
    'Handle paren alignment issues' :
        topic:
            '''
            foo
              .bar (
                baz
              ) ->
                return

            foo
              .bar (baz) ->
                return

            bar (
              baz
            ) ->
              return
            '''

        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    # Fixes #312
    'Handles empty if statements':
        topic:
            '''
              x = ->
                for a in tokens
                  if a.type is "image"
                    "image"
                  else if a.type is "video" # ignore video for now!
                  else
                    "unknown"
            '''

        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

    # Fix #348
    'Handle off-indentation bug from arguments that should be ignored':
        topic:
            '''
            angular.module('app', ['abc']).run([
              '$a'
              '$b'
              ($xyz
               $tuv
               $qrs) ->
                $http
                  .get '/'
                  .respond -> []
            ])
            '''

        'is permitted': (source) ->
            errors = coffeelint.lint(source)
            assert.isEmpty(errors)

}).export(module)