ginkgo_ast_nodes.go

package convert

import (
    "fmt"
    "go/ast"
    "strings"
    "unicode"
)

/*
 * Creates a func init() node
 */
func createVarUnderscoreBlock() *ast.ValueSpec {
    valueSpec := &ast.ValueSpec{}
    object := &ast.Object{Kind: 4, Name: "_", Decl: valueSpec, Data: 0}
    ident := &ast.Ident{Name: "_", Obj: object}
    valueSpec.Names = append(valueSpec.Names, ident)
    return valueSpec
}

/*
 * Creates a Describe("Testing with ginkgo", func() { }) node
 */
func createDescribeBlock() *ast.CallExpr {
    blockStatement := &ast.BlockStmt{List: []ast.Stmt{}}

    fieldList := &ast.FieldList{}
    funcType := &ast.FuncType{Params: fieldList}
    funcLit := &ast.FuncLit{Type: funcType, Body: blockStatement}
    basicLit := &ast.BasicLit{Kind: 9, Value: "\"Testing with Ginkgo\""}
    describeIdent := &ast.Ident{Name: "Describe"}
    return &ast.CallExpr{Fun: describeIdent, Args: []ast.Expr{basicLit, funcLit}}
}

/*
 * Convenience function to return the name of the *testing.T param
 * for a Test function that will be rewritten. This is useful because
 * we will want to replace the usage of this named *testing.T inside the
 * body of the function with a GinktoT.
 */
func namedTestingTArg(node *ast.FuncDecl) string {
    return node.Type.Params.List[0].Names[0].Name // *exhale*
}

/*
 * Convenience function to return the block statement node for a Describe statement
 */
func blockStatementFromDescribe(desc *ast.CallExpr) *ast.BlockStmt {
    var funcLit *ast.FuncLit
    var found = false

    for _, node := range desc.Args {
        switch node := node.(type) {
        case *ast.FuncLit:
            found = true
            funcLit = node
            break
        }
    }

    if !found {
        panic("Error finding ast.FuncLit inside describe statement. Somebody done goofed.")
    }

    return funcLit.Body
}

/* convenience function for creating an It("TestNameHere")
 * with all the body of the test function inside the anonymous
 * func passed to It()
 */
func createItStatementForTestFunc(testFunc *ast.FuncDecl) *ast.ExprStmt {
    blockStatement := &ast.BlockStmt{List: testFunc.Body.List}
    fieldList := &ast.FieldList{}
    funcType := &ast.FuncType{Params: fieldList}
    funcLit := &ast.FuncLit{Type: funcType, Body: blockStatement}

    testName := rewriteTestName(testFunc.Name.Name)
    basicLit := &ast.BasicLit{Kind: 9, Value: fmt.Sprintf("\"%s\"", testName)}
    itBlockIdent := &ast.Ident{Name: "It"}
    callExpr := &ast.CallExpr{Fun: itBlockIdent, Args: []ast.Expr{basicLit, funcLit}}
    return &ast.ExprStmt{X: callExpr}
}

/*
* rewrite test names to be human readable
* eg: rewrites "TestSomethingAmazing" as "something amazing"
 */
func rewriteTestName(testName string) string {
    nameComponents := []string{}
    currentString := ""
    indexOfTest := strings.Index(testName, "Test")
    if indexOfTest != 0 {
        return testName
    }

    testName = strings.Replace(testName, "Test", "", 1)
    first, rest := testName[0], testName[1:]
    testName = string(unicode.ToLower(rune(first))) + rest

    for _, rune := range testName {
        if unicode.IsUpper(rune) {
            nameComponents = append(nameComponents, currentString)
            currentString = string(unicode.ToLower(rune))
        } else {
            currentString += string(rune)
        }
    }

    return strings.Join(append(nameComponents, currentString), " ")
}

func newGinkgoTFromIdent(ident *ast.Ident) *ast.CallExpr {
    return &ast.CallExpr{
        Lparen: ident.NamePos + 1,
        Rparen: ident.NamePos + 2,
        Fun:    &ast.Ident{Name: "GinkgoT"},
    }
}

func newGinkgoTInterface() *ast.Ident {
    return &ast.Ident{Name: "GinkgoTInterface"}
}