From 810f9bebef47d6cc0efed1e2f5689c8d8dbacef7 Mon Sep 17 00:00:00 2001 From: Abiola Ibrahim Date: Mon, 11 Jan 2016 07:28:46 +0100 Subject: [PATCH] type name refactor --- caddy/setup/rewrite.go | 8 ++++---- middleware/path.go | 34 +++++++++++++++++----------------- middleware/path_test.go | 18 +++++++++--------- middleware/proxy/proxy.go | 2 +- middleware/proxy/upstream.go | 8 ++++---- middleware/rewrite/rewrite.go | 6 +++--- 6 files changed, 38 insertions(+), 38 deletions(-) diff --git a/caddy/setup/rewrite.go b/caddy/setup/rewrite.go index b4731a37e..592f6c363 100644 --- a/caddy/setup/rewrite.go +++ b/caddy/setup/rewrite.go @@ -104,19 +104,19 @@ func rewriteParse(c *Controller) ([]rewrite.Rule, error) { } - var configPaths middleware.ConfigPaths + var configs middleware.Configs // put simple rules in front to avoid regexp computation for them for _, v := range append(simpleRules, complexRules...) { // order by longest path - configPaths.Add(v) + configs.Add(v) } var rules []rewrite.Rule // add to rules after ordering - configPaths.Each(func(b middleware.ConfigPath) { - rule, _ := b.(rewrite.Rule) + configs.Each(func(c middleware.Config) { + rule, _ := c.(rewrite.Rule) rules = append(rules, rule) }) diff --git a/middleware/path.go b/middleware/path.go index 4f31d79c7..9fd74474b 100644 --- a/middleware/path.go +++ b/middleware/path.go @@ -14,35 +14,35 @@ func (p Path) Matches(other string) bool { return strings.HasPrefix(string(p), other) } -// ConfigPath represents a configuration base path. -type ConfigPath interface { +// Config represents a configuration. +type Config interface { // Path returns base path value. Path() string } -// ConfigPaths is a list of ConfigPath -type ConfigPaths []ConfigPath +// Configs is a list of Config +type Configs []Config -// Add adds a new ConfigPath to the list in descending order of +// Add adds a new Config to the list in descending order of // path length. -func (paths *ConfigPaths) Add(b ConfigPath) { - idx := len(*paths) - for i, p := range *paths { - if len(p.Path()) < len(b.Path()) { +func (configs *Configs) Add(c Config) { + idx := len(*configs) + for i, config := range *configs { + if len(config.Path()) < len(c.Path()) { idx = i break } } - part := []ConfigPath{b} - if idx < len(*paths) { - part = append(part, (*paths)[idx:]...) + part := []Config{c} + if idx < len(*configs) { + part = append(part, (*configs)[idx:]...) } - *paths = append((*paths)[:idx], part...) + *configs = append((*configs)[:idx], part...) } -// Each iterates through all config paths and calls f on each iteration -func (paths ConfigPaths) Each(f func(ConfigPath)) { - for _, p := range paths { - f(p) +// Each iterates through all configs and calls f on each iteration +func (configs Configs) Each(f func(Config)) { + for _, c := range configs { + f(c) } } diff --git a/middleware/path_test.go b/middleware/path_test.go index c3d070120..0e0fc33b5 100644 --- a/middleware/path_test.go +++ b/middleware/path_test.go @@ -3,15 +3,15 @@ package middleware import "testing" func TestConfigPath(t *testing.T) { - testRules := ConfigPaths{ - testPath("/"), - testPath("/school"), - testPath("/s"), - testPath("/sch"), - testPath("/schools"), + testRules := Configs{ + testConfig("/"), + testConfig("/school"), + testConfig("/s"), + testConfig("/sch"), + testConfig("/schools"), } - rules := ConfigPaths{} + rules := Configs{} for _, r := range testRules { rules.Add(r) } @@ -28,8 +28,8 @@ func TestConfigPath(t *testing.T) { } -type testPath string +type testConfig string -func (t testPath) Path() string { +func (t testConfig) Path() string { return string(t) } diff --git a/middleware/proxy/proxy.go b/middleware/proxy/proxy.go index 8eb6e346d..64e7867a5 100644 --- a/middleware/proxy/proxy.go +++ b/middleware/proxy/proxy.go @@ -29,7 +29,7 @@ type Upstream interface { // Checks if subpath is not an ignored path IsAllowedPath(string) bool - middleware.ConfigPath + middleware.Config } // UpstreamHostDownFunc can be used to customize how Down behaves. diff --git a/middleware/proxy/upstream.go b/middleware/proxy/upstream.go index 2672110c4..f1d2467c5 100644 --- a/middleware/proxy/upstream.go +++ b/middleware/proxy/upstream.go @@ -34,7 +34,7 @@ type staticUpstream struct { IgnoredSubPaths []string } -// Path satisfies middleware.ConfigPath +// Path satisfies middleware.Config func (s staticUpstream) Path() string { return s.from } @@ -43,7 +43,7 @@ func (s staticUpstream) Path() string { // static upstreams for the proxy middleware. func NewStaticUpstreams(c parse.Dispenser) ([]Upstream, error) { var upstreams []Upstream - var configPaths middleware.ConfigPaths + var configs middleware.Configs for c.Next() { upstream := &staticUpstream{ from: "", @@ -106,11 +106,11 @@ func NewStaticUpstreams(c parse.Dispenser) ([]Upstream, error) { go upstream.HealthCheckWorker(nil) } - configPaths.Add(upstream) + configs.Add(upstream) } // retrieve in sorted order - configPaths.Each(func(c middleware.ConfigPath) { + configs.Each(func(c middleware.Config) { upstream, _ := c.(Upstream) upstreams = append(upstreams, upstream) }) diff --git a/middleware/rewrite/rewrite.go b/middleware/rewrite/rewrite.go index aa7d208c3..808fe90c4 100644 --- a/middleware/rewrite/rewrite.go +++ b/middleware/rewrite/rewrite.go @@ -57,7 +57,7 @@ type Rule interface { // Rewrite rewrites the internal location of the current request. Rewrite(http.FileSystem, *http.Request) Result - middleware.ConfigPath + middleware.Config } // SimpleRule is a simple rewrite rule. @@ -70,7 +70,7 @@ func NewSimpleRule(from, to string) SimpleRule { return SimpleRule{from, to} } -// Path satisfies middleware.ConfigPath +// Path satisfies middleware.Config func (s SimpleRule) Path() string { return s.From } @@ -142,7 +142,7 @@ func NewComplexRule(base, pattern, to string, status int, ext []string, ifs []If }, nil } -// Path satisfies middleware.ConfigPath. +// Path satisfies middleware.Config. func (r *ComplexRule) Path() string { return r.Base }