Vihren Atlas

Atlas › Test

ExampleRoute

go.temporal.io/server/common/routing/ExampleRoute

Package
go.temporal.io/server/common/routing
Suite / test hierarchy
ExampleRoute
Test
ExampleRoute
Introduced at
ExampleRoute Test frontier
Covered ranges
19
Covered lines
63
Covered files
1

Covered source

Expand a file to inspect source; the > gutter marks covered lines.

go.temporal.io/server/common/routing/route.go 63 covered LOC · 19 ranges

Open complete file

36
37 // NewRoute returns a new [Route] instance with the given components.
38 > func NewRoute[T any](components ...Component[T]) Route[T] { route.go
39 > return Route[T]{components: components}
40 > }
41
42 // RouteBuilder is a builder for the [Route] interface.
46
47 // NewBuilder creates a new [RouteBuilder] instance, which can be used to define a new [Route] via a fluent API.
48 > func NewBuilder[T any]() *RouteBuilder[T] { route.go
49 > return &RouteBuilder[T]{}
50 > }
51
52 // With adds a series of [Component] instances to the [Route].
53 > func (r *RouteBuilder[T]) With(c ...Component[T]) *RouteBuilder[T] { route.go
54 > r.components = append(r.components, c...)
55 > return r
56 > }
57
58 // Constant adds a [Constant] component to the [Route].
59 > func (r *RouteBuilder[T]) Constant(values ...string) *RouteBuilder[T] { route.go
60 > return r.With(Constant[T](values...))
61 > }
62
63 // StringVariable adds a [StringVariable] component to the [Route].
64 > func (r *RouteBuilder[T]) StringVariable(name string, getter func(*T) *string) *RouteBuilder[T] { route.go
65 > return r.With(StringVariable[T](name, getter))
66 > }
67
68 // Build returns a read-only [Route].
69 > func (r *RouteBuilder[T]) Build() Route[T] { route.go
70 > return NewRoute[T](r.components...)
71 > }
72
73 // Representation returns the [github.com/gorilla/mux] compatible string representation of the route for usage in a
75 // they're present in the components. We do this because it's easier to add a slash depending on the context than to
76 // remove it.
77 > func (r Route[T]) Representation() string { route.go
78 > return r.serialize(func(c Component[T]) string {
79 > return c.Representation()
80 > })
81 }
82
83 // Path returns the serialized path of the route with the given params. There will be no leading or trailing slashes,
84 // similar to the behavior of the [Route.Representation] method.
85 > func (r Route[T]) Path(t T) string { route.go
86 > return r.serialize(func(c Component[T]) string {
87 > return c.Serialize(t)
88 > })
89 }
90
91 > func (r Route[T]) serialize(f func(c Component[T]) string) string { route.go
92 > var sb strings.Builder
93 > for i, c := range r.components {
94 > if i > 0 {
95 > sb.WriteString("/")
96 > }
97 > sb.WriteString(f(c))
98 }
99 > return sb.String() route.go
100 }
101
102 // Deserialize the given vars into a new instance of the params type, T.
103 > func (r Route[T]) Deserialize(vars map[string]string) T { route.go
104 > var t T
105 > for _, c := range r.components {
106 > c.Deserialize(vars, &t)
107 > }
108 > return t
109 }
110
111 // Constant returns a [Component] that represents a series of constant HTTP path components in a Route.
112 // They will be joined via strings when used to construct a path or path representation.
113 > func Constant[T any](values ...string) constant[T] { route.go
114 > return values
115 > }
116
117 type constant[T any] []string
118
119 > func (s constant[T]) Representation() string { route.go
120 > return strings.Join(s, "/")
121 > }
122
123 > func (s constant[T]) Serialize(T) string { route.go
124 > return strings.Join(s, "/")
125 > }
126
127 > func (s constant[T]) Deserialize(map[string]string, *T) {} route.go
128
129 // StringVariable returns a [Component] that represents a string variable in a Route.
130 > func StringVariable[T any](name string, getter func(*T) *string) stringVariable[T] { route.go
131 > return stringVariable[T]{name, getter}
132 > }
133
134 type stringVariable[T any] struct {
137 }
138
139 > func (s stringVariable[T]) Representation() string { route.go
140 > return "{" + s.name + "}"
141 > }
142
143 > func (s stringVariable[T]) Serialize(t T) string { route.go
144 > return url.PathEscape(*s.getter(&t))
145 > }
146
147 > func (s stringVariable[T]) Deserialize(vars map[string]string, t *T) { route.go
148 > *s.getter(t) = vars[s.name]
149 > }