Clover Coverage Report - Pebble 2.5-SNAPSHOT
Coverage timestamp: Sat Jun 12 2010 09:39:29 EST
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../img/srcFileCovDistChart7.png 33% of files have more coverage
96   272   36   6
36   163   0,38   16
16     2,25  
1    
This report was generated with an evaluation server license. Purchase Clover or configure your license.
 
  ResponseIndex       Line # 22 96 0% 36 46 68,9% 0.6891892
 
  (54)
 
1    package net.sourceforge.pebble.index;
2   
3    import net.sourceforge.pebble.comparator.ReverseResponseIdComparator;
4    import net.sourceforge.pebble.domain.Blog;
5    import net.sourceforge.pebble.domain.BlogEntry;
6    import net.sourceforge.pebble.domain.Response;
7    import net.sourceforge.pebble.domain.State;
8    import org.apache.commons.logging.Log;
9    import org.apache.commons.logging.LogFactory;
10   
11    import java.io.*;
12    import java.util.ArrayList;
13    import java.util.Collections;
14    import java.util.List;
15    import java.util.Collection;
16   
17    /**
18    * Keeps an index of all responses.
19    *
20    * @author Simon Brown
21    */
 
22    public class ResponseIndex {
23   
24    private static final Log log = LogFactory.getLog(ResponseIndex.class);
25   
26    private Blog blog;
27   
28    private List<String> approvedResponses = new ArrayList<String>();
29    private List<String> pendingResponses = new ArrayList<String>();
30    private List<String> rejectedResponses = new ArrayList<String>();
31   
 
32  1334 toggle public ResponseIndex(Blog blog) {
33  1334 this.blog = blog;
34   
35  1334 approvedResponses = readIndex(State.APPROVED);
36  1334 pendingResponses = readIndex(State.PENDING);
37  1334 rejectedResponses = readIndex(State.REJECTED);
38    }
39   
40    /**
41    * Clears the index.
42    */
 
43  18 toggle public void clear() {
44  18 approvedResponses = new ArrayList<String>();
45  18 writeIndex(State.APPROVED);
46   
47  18 pendingResponses = new ArrayList<String>();
48  18 writeIndex(State.PENDING);
49   
50  18 rejectedResponses = new ArrayList<String>();
51  18 writeIndex(State.REJECTED);
52    }
53   
54    /**
55    * Indexes one or more blog entries.
56    *
57    * @param blogEntries a List of BlogEntry instances
58    */
 
59  18 toggle public synchronized void index(Collection<BlogEntry> blogEntries) {
60  18 for (BlogEntry blogEntry : blogEntries) {
61  18 for (Response response : blogEntry.getResponses()) {
62  6 if (response.isApproved()) {
63  0 approvedResponses.add(response.getGuid());
64  6 } else if (response.isPending()) {
65  6 pendingResponses.add(response.getGuid());
66  0 } else if (response.isRejected()) {
67  0 rejectedResponses.add(response.getGuid());
68    }
69    }
70    }
71   
72  18 Collections.sort(approvedResponses, new ReverseResponseIdComparator());
73  18 Collections.sort(pendingResponses, new ReverseResponseIdComparator());
74  18 Collections.sort(rejectedResponses, new ReverseResponseIdComparator());
75  18 writeIndex(State.APPROVED);
76  18 writeIndex(State.PENDING);
77  18 writeIndex(State.REJECTED);
78    }
79   
80    /**
81    * Indexes a single response.
82    *
83    * @param response a Response instance
84    */
 
85  144 toggle public synchronized void index(Response response) {
86  144 if (response.isApproved()) {
87  60 approvedResponses.add(response.getGuid());
88  60 Collections.sort(approvedResponses, new ReverseResponseIdComparator());
89  60 writeIndex(State.APPROVED);
90  84 } else if (response.isPending()) {
91  80 pendingResponses.add(response.getGuid());
92  80 Collections.sort(pendingResponses, new ReverseResponseIdComparator());
93  80 writeIndex(State.PENDING);
94  4 } else if (response.isRejected()) {
95  4 rejectedResponses.add(response.getGuid());
96  4 Collections.sort(rejectedResponses, new ReverseResponseIdComparator());
97  4 writeIndex(State.REJECTED);
98    }
99    }
100   
101    /**
102    * Unindexes a single response.
103    *
104    * @param response a Response instance
105    */
 
106  76 toggle public synchronized void unindex(Response response) {
107  76 if (approvedResponses.contains(response.getGuid())) {
108  8 approvedResponses.remove(response.getGuid());
109  8 writeIndex(State.APPROVED);
110  68 } else if (pendingResponses.contains(response.getGuid())) {
111  68 pendingResponses.remove(response.getGuid());
112  68 writeIndex(State.PENDING);
113  0 } else if (rejectedResponses.contains(response.getGuid())) {
114  0 rejectedResponses.remove(response.getGuid());
115  0 writeIndex(State.REJECTED);
116    }
117    }
118   
119    /**
120    * Helper method to load the index.
121    */
 
122  4002 toggle private List<String> readIndex(State state) {
123  4002 String filename = null;
124  4002 List<String> responses = new ArrayList<String>();
125  4002 if (state == State.APPROVED) {
126  1334 filename = "responses-approved.index";
127  2668 } else if (state == State.PENDING) {
128  1334 filename = "responses-pending.index";
129  1334 } else if (state == State.REJECTED) {
130  1334 filename = "responses-rejected.index";
131    }
132   
133  4002 File indexFile = new File(blog.getIndexesDirectory(), filename);
134  4002 if (indexFile.exists()) {
135  0 try {
136  0 BufferedReader reader = new BufferedReader(new FileReader(indexFile));
137  0 String response = reader.readLine();
138  0 while (response != null) {
139  0 responses.add(response);
140  0 response = reader.readLine();
141    }
142   
143  0 reader.close();
144    } catch (Exception e) {
145  0 log.error("Error while reading index", e);
146    }
147    }
148   
149  4002 Collections.sort(responses, new ReverseResponseIdComparator());
150   
151  4002 return responses;
152    }
153   
154    /**
155    * Helper method to write out the index to disk.
156    */
 
157  328 toggle private void writeIndex(State state) {
158  328 String filename = null;
159  328 List<String> responses = null;
160  328 if (state == State.APPROVED) {
161  104 filename = "responses-approved.index";
162  104 responses = approvedResponses;
163  224 } else if (state == State.PENDING) {
164  184 filename = "responses-pending.index";
165  184 responses = pendingResponses;
166  40 } else if (state == State.REJECTED) {
167  40 filename = "responses-rejected.index";
168  40 responses = rejectedResponses;
169    }
170   
171  328 try {
172  328 File indexFile = new File(blog.getIndexesDirectory(), filename);
173  328 BufferedWriter writer = new BufferedWriter(new FileWriter(indexFile));
174   
175  328 for (String response : responses) {
176  1212 writer.write(response);
177  1212 writer.newLine();
178    }
179   
180  328 writer.flush();
181  328 writer.close();
182    } catch (Exception e) {
183  0 log.error("Error while writing index", e);
184    }
185    }
186   
187    /**
188    * Gets the number of approved responses for this blog.
189    *
190    * @return an int
191    */
 
192  0 toggle public int getNumberOfApprovedResponses() {
193  0 return approvedResponses.size();
194    }
195   
196    /**
197    * Gets the number of pending responses for this blog.
198    *
199    * @return an int
200    */
 
201  0 toggle public int getNumberOfPendingResponses() {
202  0 return pendingResponses.size();
203    }
204   
205    /**
206    * Gets the number of rejected responses for this blog.
207    *
208    * @return an int
209    */
 
210  0 toggle public int getNumberOfRejectedResponses() {
211  0 return rejectedResponses.size();
212    }
213   
214    /**
215    * Gets the number of responses for this blog.
216    *
217    * @return an int
218    */
 
219  0 toggle public int getNumberOfResponses() {
220  0 return getNumberOfApprovedResponses() + getNumberOfPendingResponses() + getNumberOfRejectedResponses();
221    }
222   
223    /**
224    * Gets the most recent N approved responses.
225    *
226    * @return a List of response IDs
227    */
 
228  0 toggle public List<String> getRecentResponses(int number) {
229  0 return getRecentApprovedResponses(number);
230    }
231   
232    /**
233    * Gets the most recent N approved responses.
234    *
235    * @return a List of response IDs
236    */
 
237  0 toggle public List<String> getRecentApprovedResponses(int number) {
238  0 if (approvedResponses.size() >= number) {
239  0 return approvedResponses.subList(0, number);
240    } else {
241  0 return approvedResponses;
242    }
243    }
244   
245    /**
246    * Gets the list of approved responses.
247    *
248    * @return a List of response IDs
249    */
 
250  16 toggle public List<String> getApprovedResponses() {
251  16 return new ArrayList<String>(approvedResponses);
252    }
253   
254    /**
255    * Gets the list of pending responses.
256    *
257    * @return a List of response IDs
258    */
 
259  12 toggle public List<String> getPendingResponses() {
260  12 return new ArrayList<String>(pendingResponses);
261    }
262   
263    /**
264    * Gets the list of rejected responses.
265    *
266    * @return a List of response IDs
267    */
 
268  0 toggle public List<String> getRejectedResponses() {
269  0 return new ArrayList<String>(rejectedResponses);
270    }
271   
272    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Sat Jun 12 2010 09:39:50 EST.		   Clover Evaluation License registered to Clover Maven Plugin. You have 20 day(s) before your license expires.