I've been toying with the idea of using uritemplates for go-github for a little while now. In particular, I'm interested in trying to clean up some of the code I have for appending query parameters, that currently looks something like:

type ListOptions struct {
        Page int
}

func (s *OrganizationsService) List(user string, opt *ListOptions) ([]Organization, error) {
        u := fmt.Sprintf("users/%v/orgs", user)
        if opt != nil {
                params := url.Values{
                        "page": []string{strconv.Itoa(opt.Page)},
                }
                u += "?" + params.Encode()
        }
        ...
}

For small option types this isn't too bad, but gets worse with larger ones and just seems like it could be cleaner. What I've been thinking about is mimicking how encoding/json and encoding/xml use field tags. So something like:

type ListOptions struct {
        Page int `url:"page"`
}

func (s *OrganizationsService) List(user string, opt *ListOptions) ([]Organization, error) {
        u := fmt.Sprintf("users/%v/orgs", user)
        u += uritemplates.Parse("{?page}").Expand(ListOptions)
        ...
}

Of course, I would ideally just have a single line with a template of users/{user}/orgs{?page}, but I haven't decided on the best way to pass the user into Expand() yet. I don't want to put it in ListOptions since it's a required parameter to the List() function and I want that to be explicit.

There are of course ways to do this by converting the struct into a map first, and then passing that to Expand(), but I figured I'd float this idea to you and see what you thought.

Its would be handy if we can match and extract value from an url, for example:

template, _ := uritemplates.Parse("api.github.com/repos{/user,repo}") agrs := make(map[string]interface{}) if template.Match("api.github.com/repos/jtacoma/uritemplates", args) { fmt.Println(map["user"]) // jtacoma fmt.Println(map["repo"]) // uritemplates }

I'm currently packaging your library in Debian, as a dependency of several other packages.

You currently do not tag any recent releases, and this makes it harder for downstream packagers. (Also, referring to specific commits is awkward)

I've got a project that uses URI templates from external sources, and before expanding, I'd like to ensure all of the prerequisite data is available. So I've added the ExpressionNames function to URITemplate that will return the list of names referenced by the template.

I may be overlooking a corner case; if there are additional tests needed, or if they should be broken out into their own test instead of just piggybacking on Expand's tests, I'm happy to do that.

/ Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file.

Do you consider MIT a BSD-style license? Or was there another license before?

This seemed like a promising improvement on paper but benchmarks currently included in the uritemplates_test.go show no significant differences so I'm submitting this pull request as a request for comments.

uritemplates.Parse() gives error if the path has hyphen in one of the path-param name.

Example : template, parseErr := uritemplates.Parse("https://api.github.com/repos/{repo-name}")

Gives error : not a valid name: repo-name

I am not able to comprehend why shouldn't this be allowed ? the regex used for validation is -----> "^([A-Za-z0-9_\.]|%[0-9A-Fa-f][0-9A-Fa-f])+$"

Currently this code handles missing keys correctly, but a key that exists and has been explicitly set to nil causes a panic. This handles it the same way as a key that doesn't exist.