Bring coverage closer to 100%.
Cover at least conditional branches that cannot be covered.

Description

Run benchmark tests in the latest environment

goblin: [1.0.0](https://github.com/bmf-san/goblin/releases/tag/1.1.0) → Run with latest version!
Golang version: 1.14 → Run with latest version!
Model Name: MacBook Air
Model Identifier: MacBookAir8,1
Processor Name: Dual-Core Intel Core i5
Processor Speed: 1.6 GHz
Number of Processors: 1
Total Number of Cores: 2
Memory: 16 GB

Tasks

• Run benchmark tests with latest environment.
• Update benchmark section in README.md

Description

Add test case name to test cases.

ex.

t.Run(testname, func(t *testing.T) {
　// do something
})

I want to set the name because it is difficult to understand which test case failed.

Describe the feature you'd like to request

Describe the solution you'd like

Description

I noticed a data structure problem while considering implementing middleware for CORS.
In the current structure of the trie tree, HTTP verb matching is indispensable for routing matching.
This is inconvenient for middleware application.
There are cases where you want to apply middleware processing before determining HTTP verb matching.

Todo

Modify the data structure so that the Node has an HTTP verb.

Description

The tree that Router has might as well be a map.

tree                 map[string]*tree   // key is http method

cf. https://github.com/bmf-san/goblin/blob/master/router.go#L11

Describe the feature you'd like to request

For data structure optimization.

Describe the solution you'd like

Need to prove efficency by benchmark tests.

Description

	r := goblin.NewRouter()

	r.GET(`/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "/")
	}))
	r.GET(`/foo/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "/foo/")
	}))
	r.GET(`/foo/bar/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "/foo/bar/")
	}))
	r.GET(`/foo/bar/:id/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		id := goblin.GetParam(r.Context(), "id")
		fmt.Fprintf(w, "/foo/bar/%v/", id)
	}))
        ...

This definition expects access to the following URI,

/
/foo/
/foo/bar/
/foo/bar/{id} ex. /foo/bar/1

But in fact, I don't know why I can access undefined URIs without any errors.

/hoge → No errors, and return responses for /.

Description

Improve allocation to 0 allocs in the path parameter test cases.

make test-benchmark CPU=1 COUNT=1

go test -bench=. -cpu=1 -benchmem -count=1
goos: darwin
goarch: arm64
pkg: github.com/bmf-san/goblin
BenchmarkStaticRoutesRootGoblin         75517075                15.65 ns/op            0 B/op          0 allocs/op
BenchmarkStaticRoutes1Goblin            39804074                29.65 ns/op            0 B/op          0 allocs/op
BenchmarkStaticRoutes5Goblin             9692804               124.4 ns/op             0 B/op          0 allocs/op
BenchmarkStaticRoutes10Goblin            4268844               280.4 ns/op             0 B/op          0 allocs/op
BenchmarkPathParamRoutes1ColonGoblin     6099525               199.8 ns/op           328 B/op          3 allocs/op  // here
BenchmarkPathParamRoutes5ColonGoblin     3435362               350.5 ns/op           328 B/op          3 allocs/op // here
BenchmarkPathParamRoutes10ColonGoblin    2185375               553.1 ns/op           328 B/op          3 allocs/op  // here
PASS
ok      github.com/bmf-san/goblin       10.852s

Describe the feature you'd like to request

I think it's probably due to the processing of the path parameter in the search method.
https://github.com/bmf-san/goblin/blob/master/trie.go#L250-L263

Describe the solution you'd like

Umm...

Description

Support Request.PathValue for compatibility.

Describe the feature you'd like to request

cf. go-chi/chi#901
cf. go-chi/chi#873

Describe the solution you'd like

cf. go-chi/chi#901
cf. go-chi/chi#873

Description

As a title.

Description

DisableGeneralOptionsHandler will be available in go1.20.

Describe the feature you'd like to request

Want to have an option that can set the DisableGeneralOptionsHandler.

Describe the solution you'd like

About this issue.
golang/go#61410

I can't say anything definitive because I don't know what the final implementation will be, but I think it will be easier to consider the option of using standard ServeMux instead of using third-party libraries.

I think that the reasons for using third-party libraries are good performance and richness of functions.

Regarding the future of goblin, we intend to continue maintenance for a while.
For applications that personally use goblin, I might switch to the standard ServeMux.
It's hard to say whether goblin will have any advantages over the new ServeMux, but one thing that seems likely is support for regular expressions.

io/ioutil has been deprecated since Go 1.16.
Replace it to io.

here:
https://github.com/bmf-san/goblin/blob/master/router_test.go#L5

Due to this correspondence, support for Go1.15 will be terminated.

Such like GIN, group can quickly create sub routers for modules with same middlewares. Is there any way to support group or just in feature?

For eg.:

r := goblin.NewRouter()
group :=r.Group("/module1")
group.Use(someMiddlwareOnlyForThisGroup)

group.Methods(http.MethodGet).Handler("/freeAPI", ...)
group.Methods(http.MethodGet).Use(Authenticator).Handler("/secretAPI", ...)

Description

There are few test cases, so reconsider it for reducing bugs and improving quality.

Todo

• To reconsider test cases.

cf. https://github.com/go-chi/chi

Description

This diagram is out of date and will be updated.

cf. #88

Describe the feature you'd like to request

Update diagram.

Describe the solution you'd like

Write new diagram.

cf. https://github.com/bmf-san/goblin/blob/master/router.go#L25-L28

Description

router package has not have a method for OPTION.

Description

Support a OPTION method.
I want to be able to handle preflight requests.

Description

Go regexp lib is slow so we need to improve perfomance.
bmf-go-router uses regexp for routing pattern with regular expression.

Solution

Initializing regexp pattern is costly, maybe this will be solved by initializing regexp pattern as global variables.

Example

var re = regexp.MustCompile("[a-z]{3}")

func main() {
    fmt.Println(re.FindAllString("foobar", -1))
    // => [foo bar]
}

Description

Add benchmark tests for dynamic routes.

Currently support only static routes.

Or examine another idea for benchmark.
cf. julienschmidt/go-http-routing-benchmark

Description

Want to investigate bmf-go-router perfomance.

Todo

• To prepare benchmark tests.

Description

To refactor pkg structure.

ex.

router
trie
↓
router
trie
param
path
...

Description

As a title.

Better

func CORS(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Max-Age", "86400")
		w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, PATCH")
		w.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type, Content-Length, Accept-Encoding, Authorization, Access-Control-Allow-Origin")
		w.Header().Set("Access-Control-Expose-Headers", "Content-Length, Pagination-Count, Pagination-Pagecount, Pagination-Page, Pagination-Limit")

		next.ServeHTTP(w, r)
	})
}

r.GET(`/`).Use(first).Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "CORS")
}))
r.OPTIONS(`/`).Use(CORS).Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    return
}))

More better

func CORS(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Max-Age", "86400")
		w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, PATCH")
		w.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type, Content-Length, Accept-Encoding, Authorization, Access-Control-Allow-Origin")
		w.Header().Set("Access-Control-Expose-Headers", "Content-Length, Pagination-Count, Pagination-Pagecount, Pagination-Page, Pagination-Limit")

		next.ServeHTTP(w, r)
	})
}

r.Methods(http.MethodGet, httpp.MethodOptions).Use(first).Handler(`/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "CORS")
}))

I think above pattern is more better.

References

https://github.com/gorilla/mux#handling-cors-requests

Description

I feel that the error message is messy, so I want to make it feel good.

Task

Improve some error messages.

Error message improvement points

• What kind of error is it?
• Why did the error occur?
• If the cause is clear, describe the cause.　

Do you have any other good ideas?

Example of the part I want to fix

etc...

Description

To prepare an example for using goblin with middleware.

Todo

Adding an examle for using goblin with middleware to README.