benhoyt/router.go Secret

## 76 changes: 76 additions & 0 deletions router.go
@@ -0,0 +1,76 @@

    /*
/*

    From Yuri Vishnevsky on Gophers Slack:
From Yuri Vishnevsky on Gophers Slack:

    Hi Ben! I read your great post on Go routing. Based on
Hi Ben! I read your great post on Go routing. Based on

    the ideas there I wound up implementing my own router for a small
the ideas there I wound up implementing my own router for a small

    site I'm building, which combines a few ideas from your post.Instead
site I'm building, which combines a few ideas from your post.Instead

    of passing a format string followed by pieces as in match
of passing a format string followed by pieces as in match

    ("foo/+/baz", &bar) I decided to inline the pieces, so the match
("foo/+/baz", &bar) I decided to inline the pieces, so the match

    arguments read as the path does: match("foo", &bar, "baz"). I'm
arguments read as the path does: match("foo", &bar, "baz"). I'm

    curious if you have any thoughts, since this seems quite nice to me,
curious if you have any thoughts, since this seems quite nice to me,

    and has a simple implementation. No worries if you're too busy to
and has a simple implementation. No worries if you're too busy to

    think about this right now; I just thought you might find it
think about this right now; I just thought you might find it

    interesting.
interesting.

    */
*/


    package main
package main


    import (
import (

        "fmt"
    "fmt"

        "strconv"
    "strconv"

        "strings"
    "strings"

    )
)


    // match reports whether `path` matches the given `pieces`
// match reports whether `path` matches the given `pieces`

    // and assigns pointer pieces. A piece can be a string,
// and assigns pointer pieces. A piece can be a string,

    // *string, or *int64. This function matches pieces greedily
// *string, or *int64. This function matches pieces greedily

    // and may assign pieces even when the path does not match.
// and may assign pieces even when the path does not match.

    // Note: Does not normalize paths with path.Clean.
// Note: Does not normalize paths with path.Clean.

    // Note: Consecutive string path components need to be matched
// Note: Consecutive string path components need to be matched

    // with separate strings, since this always splits on /.
// with separate strings, since this always splits on /.

    func match(path string, pieces ...interface{}) bool {
func match(path string, pieces ...interface{}) bool {

        // Remove the initial "/" prefix
    // Remove the initial "/" prefix

        if strings.HasPrefix(path, "/") {
    if strings.HasPrefix(path, "/") {

            path = path[1:]
        path = path[1:]

        }
    }

        var head string
    var head string

        for i, piece := range pieces {
    for i, piece := range pieces {

            // Shift the next path component into `head`
        // Shift the next path component into `head`

            head, path = nextComponent(path)
        head, path = nextComponent(path)

            // Match pieces based on their type
        // Match pieces based on their type

            switch p := piece.(type) {
        switch p := piece.(type) {

            case string:
        case string:

                // Match a specific string
            // Match a specific string

                if p != head {
            if p != head {

                    return false
                return false

                }
            }

            case *string:
        case *string:

                // Match any string, including the empty string
            // Match any string, including the empty string

                *p = head
            *p = head

            case *int64:
        case *int64:

                // Match any 64-bit integer, including negative integers
            // Match any 64-bit integer, including negative integers

                n, err := strconv.ParseInt(head, 10, 64)
            n, err := strconv.ParseInt(head, 10, 64)

                if err != nil {
            if err != nil {

                    return false
                return false

                }
            }

                *p = n
            *p = n

            default:
        default:

                panic(fmt.Sprintf("each piece must be a string, *string, or *int64. Got %T", piece))
            panic(fmt.Sprintf("each piece must be a string, *string, or *int64. Got %T", piece))

            }
        }

            // If the path is fully consumed, we're done if pieces are also fully consumed
        // If the path is fully consumed, we're done if pieces are also fully consumed

            if path == "" {
        if path == "" {

                return i == len(pieces)-1
            return i == len(pieces)-1

            }
        }

        }
    }

        // Pieces are consumed; return true if the path is too.
    // Pieces are consumed; return true if the path is too.

        return path == ""
    return path == ""

    }
}


    // Accepts a path without leading slash and returns two strings:
// Accepts a path without leading slash and returns two strings:

    // its first component and the rest without leading slash
// its first component and the rest without leading slash

    func nextComponent(path string) (head, tail string) {
func nextComponent(path string) (head, tail string) {

        i := strings.IndexByte(path, '/')
    i := strings.IndexByte(path, '/')

        if i == -1 {
    if i == -1 {

            return path, ""
        return path, ""

        }
    }

        return path[:i], path[i+1:]
    return path[:i], path[i+1:]

    }
}