1. Project Clover database Mon Aug 27 2018 22:12:52 BRT
  2. Package net.technearts.rip

File RipRoute.java

 

Coverage histogram

../../../img/srcFileCovDistChart4.png
42% of files have more coverage

Code metrics

2
95
22
1
283
181
49
0.52
4.32
22
2.23

Classes

Class Line # Actions
RipRoute 31 95 0% 49 74
0.3781512737.8%
 

Contributing tests

This file is covered by 6 tests. .

Source view

1    package net.technearts.rip;
2   
3    import static java.util.Objects.hash;
4    import static spark.route.HttpMethod.connect;
5    import static spark.route.HttpMethod.delete;
6    import static spark.route.HttpMethod.get;
7    import static spark.route.HttpMethod.head;
8    import static spark.route.HttpMethod.options;
9    import static spark.route.HttpMethod.patch;
10    import static spark.route.HttpMethod.post;
11    import static spark.route.HttpMethod.put;
12    import static spark.route.HttpMethod.trace;
13   
14    import java.util.Objects;
15   
16    import org.slf4j.Logger;
17    import org.slf4j.LoggerFactory;
18   
19    import com.google.common.collect.ComparisonChain;
20   
21    import freemarker.template.Configuration;
22    import spark.Route;
23    import spark.TemplateEngine;
24    import spark.TemplateViewRoute;
25    import spark.route.HttpMethod;
26    import spark.template.freemarker.FreeMarkerEngine;
27   
28    /**
29    * Uma rota (Verbo http + Caminho) associado a um servidor Rip
30    */
 
31    public class RipRoute implements Comparable<RipRoute>, AutoCloseable {
32    private static final Logger LOG = LoggerFactory.getLogger(RipRoute.class);
33    private static final Configuration CFG = FreemarkerConfiguration
34    .getDefaultConfiguration();
35    private final RipServer ripServer;
36    private HttpMethod method;
37    private String path;
38    Route route;
39    TemplateViewRoute templateRoute;
40   
 
41  9 toggle RipRoute(final RipServer ripServer) {
42  9 this.ripServer = ripServer;
43    }
44   
 
45  0 toggle @Override
46    public void close() {
47    // TODO
48    }
49   
 
50  0 toggle @Override
51    public int compareTo(final RipRoute that) {
52  0 return ComparisonChain.start().compare(ripServer, that.ripServer)
53    .compare(method, that.method).compare(path, that.path).result();
54    }
55   
56    /**
57    * Configura o RipRoute para método connect no caminho <code>path</code>
58    *
59    * @param path o caminho da requisição http a ser criado
60    * @return um <code>RipResponseBuilder</code> para a construção da resposta
61    * desse RipRoute
62    */
 
63  0 toggle public RipResponseBuilder connect(final String path) {
64  0 return create(path, connect);
65    }
66   
 
67  9 toggle private RipResponseBuilder create(final String path,
68    final HttpMethod method) {
69  9 this.method = method;
70  9 this.path = path;
71  9 return new RipResponseBuilder(this);
72    }
73   
 
74  8 toggle void createMethod() {
75  8 switch (getMethod()) {
76  0 case connect:
77  0 ripServer.service.connect(path, route);
78  0 break;
79  2 case delete:
80  2 ripServer.service.delete(path, route);
81  2 break;
82  1 case get:
83  1 ripServer.service.get(path, route);
84  1 break;
85  0 case head:
86  0 ripServer.service.head(path, route);
87  0 break;
88  0 case options:
89  0 ripServer.service.options(path, route);
90  0 break;
91  0 case patch:
92  0 ripServer.service.patch(path, route);
93  0 break;
94  2 case post:
95  2 ripServer.service.post(path, route);
96  2 break;
97  3 case put:
98  3 ripServer.service.put(path, route);
99  3 break;
100  0 case trace:
101  0 ripServer.service.trace(path, route);
102  0 break;
103  0 case after:
104  0 case afterafter:
105  0 case before:
106  0 case unsupported:
107  0 default:
108  0 LOG.error("A opção {} não é suportada!", method);
109  0 break;
110    }
111    }
112   
 
113  1 toggle void createTemplateMethod() {
114    // TODO usar método render do FreeMarkerEngine em vez de passar como
115    // argumento
116  1 final TemplateEngine templateEngine = new FreeMarkerEngine(CFG);
117  1 switch (getMethod()) {
118  0 case connect:
119  0 ripServer.service.connect(path, templateRoute, templateEngine);
120  0 break;
121  0 case delete:
122  0 ripServer.service.delete(path, templateRoute, templateEngine);
123  0 break;
124  1 case get:
125  1 ripServer.service.get(path, templateRoute, templateEngine);
126  1 break;
127  0 case head:
128  0 ripServer.service.head(path, templateRoute, templateEngine);
129  0 break;
130  0 case options:
131  0 ripServer.service.options(path, templateRoute, templateEngine);
132  0 break;
133  0 case patch:
134  0 ripServer.service.patch(path, templateRoute, templateEngine);
135  0 break;
136  0 case post:
137  0 ripServer.service.post(path, templateRoute, templateEngine);
138  0 break;
139  0 case put:
140  0 ripServer.service.put(path, templateRoute, templateEngine);
141  0 break;
142  0 case trace:
143  0 ripServer.service.trace(path, templateRoute, templateEngine);
144  0 break;
145  0 case after:
146  0 case afterafter:
147  0 case before:
148  0 case unsupported:
149  0 default:
150  0 LOG.error("A opção {} não é suportada!", getMethod());
151  0 break;
152    }
153    }
154   
155    /**
156    * Configura o RipRoute para método delete no caminho <code>path</code>
157    *
158    * @param path o caminho da requisição http a ser criado
159    * @return um <code>RipResponseBuilder</code> para a construção da resposta
160    * desse RipRoute
161    */
 
162  2 toggle public RipResponseBuilder delete(final String path) {
163  2 return create(path, delete);
164    }
165   
 
166  8 toggle @Override
167    public boolean equals(final Object object) {
168  8 if (object instanceof RipRoute) {
169  8 final RipRoute that = (RipRoute) object;
170  8 return Objects.equals(ripServer, that.ripServer)
171    && Objects.equals(method, that.method)
172    && Objects.equals(path, that.path);
173    }
174  0 return false;
175    }
176   
177    /**
178    * Configura o RipRoute para método get no caminho <code>path</code>
179    *
180    * @param path o caminho da requisição http a ser criado
181    * @return um <code>RipResponseBuilder</code> para a construção da resposta
182    * desse RipRoute
183    */
 
184  2 toggle public RipResponseBuilder get(final String path) {
185  2 return create(path, get);
186    }
187   
 
188  18 toggle HttpMethod getMethod() {
189  18 return method;
190    }
191   
 
192  9 toggle String getPath() {
193  9 return path;
194    }
195   
 
196  0 toggle RipServer getRipServer() {
197  0 return ripServer;
198    }
199   
 
200  7824 toggle @Override
201    public int hashCode() {
202  7831 return hash(ripServer, method, path);
203    }
204   
205    /**
206    * Configura o RipRoute para método head no caminho <code>path</code>
207    *
208    * @param path o caminho da requisição http a ser criado
209    * @return um <code>RipResponseBuilder</code> para a construção da resposta
210    * desse RipRoute
211    */
 
212  0 toggle public RipResponseBuilder head(final String path) {
213  0 return create(path, head);
214    }
215   
216    /**
217    * Configura o RipRoute para método options no caminho <code>path</code>
218    *
219    * @param path o caminho da requisição http a ser criado
220    * @return um <code>RipResponseBuilder</code> para a construção da resposta
221    * desse RipRoute
222    */
 
223  0 toggle public RipResponseBuilder options(final String path) {
224  0 return create(path, options);
225    }
226   
227    /**
228    * Configura o RipRoute para método patch no caminho <code>path</code>
229    *
230    * @param path o caminho da requisição http a ser criado
231    * @return um <code>RipResponseBuilder</code> para a construção da resposta
232    * desse RipRoute
233    */
 
234  0 toggle public RipResponseBuilder patch(final String path) {
235  0 return create(path, patch);
236    }
237   
238    /**
239    * Configura o RipRoute para método post no caminho <code>path</code>
240    *
241    * @param path o caminho da requisição http a ser criado
242    * @return um <code>RipResponseBuilder</code> para a construção da resposta
243    * desse RipRoute
244    */
 
245  2 toggle public RipResponseBuilder post(final String path) {
246  2 return create(path, post);
247    }
248   
249    /**
250    * Configura o RipRoute para método put no caminho <code>path</code>
251    *
252    * @param path o caminho da requisição http a ser criado
253    * @return um <code>RipResponseBuilder</code> para a construção da resposta
254    * desse RipRoute
255    */
 
256  3 toggle public RipResponseBuilder put(final String path) {
257  3 return create(path, put);
258    }
259   
260    /**
261    * Remove todas as configurações de rotas
262    */
 
263  0 toggle public void reset() {
264  0 ripServer.reset();
265    }
266   
 
267  0 toggle @Override
268    public String toString() {
269  0 return String.format("RipRoute %s => %s %s]", ripServer, method, path);
270    }
271   
272    /**
273    * Configura o RipRoute para método trace no caminho <code>path</code>
274    *
275    * @param path o caminho da requisição http a ser criado
276    * @return um <code>RipResponseBuilder</code> para a construção da resposta
277    * desse RipRoute
278    */
 
279  0 toggle public RipResponseBuilder trace(final String path) {
280  0 return create(path, trace);
281    }
282   
283    }