gouda

Merge lp:~jameinel/gouda/formatting into lp:gouda

  1. formatting
  2. Merge into trunk
Proposed by John A Meinel
Status: Merged
Merged at revision: 19
Proposed branch: lp:~jameinel/gouda/formatting
Merge into: lp:gouda
Diff against target: 346 lines (+142/-141)
2 files modified
.bzrignore (+1/-0)
inmemory.go (+141/-141)
To merge this branch: bzr merge lp:~jameinel/gouda/formatting
Reviewer Review Type Date Requested Status
Eric Casteleijn Approve
Review via email: mp+130808@code.launchpad.net

Description of the change

This just runs 'go fmt' and commits the result. It also adds 'tags' to ignore files so I can more easily navigate the code.

To post a comment you must log in.
Revision history for this message
Eric Casteleijn (thisfred) wrote :

I thought I had vim running go fmt on every save, but apparently that got lost. Thanks!

review: Approve
Revision history for this message
John A Meinel (jameinel) wrote :

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 10/22/2012 03:40 PM, Eric Casteleijn wrote:
> Review: Approve
>
> I thought I had vim running go fmt on every save, but apparently
> that got lost. Thanks!
>

Yeah, inmemory.go was the only file that was missing it, so I imagine
it was just the last thing you were touching.

John
=:->

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://www.enigmail.net/

iEYEARECAAYFAlCFT7cACgkQJdeBCYSNAAOEIgCdGiJK8mqPOQuxwT2pO/ZjmH06
7vsAoIz0epW5/DfD4+SfUHYivQPkOgLc
=yT60
-----END PGP SIGNATURE-----

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== added file '.bzrignore'
2--- .bzrignore 1970-01-01 00:00:00 +0000
3+++ .bzrignore 2012-10-22 12:49:25 +0000
4@@ -0,0 +1,1 @@
5+./tags
6
7=== modified file 'inmemory.go'
8--- inmemory.go 2012-09-07 21:10:58 +0000
9+++ inmemory.go 2012-10-22 12:49:25 +0000
10@@ -1,9 +1,9 @@
11 package u1db
12
13 import (
14- "encoding/json"
15- "strings"
16- )
17+ "encoding/json"
18+ "strings"
19+)
20
21 type InvalidValueForIndex struct {
22 msg string
23@@ -14,15 +14,15 @@
24 }
25
26 type InMemoryDatabase struct {
27- replicaUid string
28+ replicaUid string
29 }
30
31 func (d *InMemoryDatabase) allocateDocRev(previous string) (string, error) {
32- vcr, err := createVectorClockRev(previous)
33- if err != nil {
34- return "", err
35- }
36
37- vcr.Increment(d.replicaUid)
38+ vcr, err := createVectorClockRev(previous)
39+ if err != nil {
40+ return "", err
41+ }
42+ vcr.Increment(d.replicaUid)
43 return vcr.AsString(), nil
44 }
45
46@@ -31,169 +31,169 @@
47 }
48
49 type InMemoryIndex struct {
50- name string
51- definition []string
52- parser *queryParser
53- getters []getter
54- values map[string]*map[string]int
55+ name string
56+ definition []string
57+ parser *queryParser
58+ getters []getter
59+ values map[string]*map[string]int
60 }
61
62 func (i *InMemoryIndex) evaluateJson(doc []byte) ([]string, error) {
63- var obj map[string]interface{}
64- err := json.Unmarshal(doc, &obj)
65- if err != nil {
66- return nil, err
67- }
68- return i.evaluate(obj)
69+ var obj map[string]interface{}
70+ err := json.Unmarshal(doc, &obj)
71+ if err != nil {
72+ return nil, err
73+ }
74+ return i.evaluate(obj)
75 }
76
77 func (i *InMemoryIndex) evaluate(obj map[string]interface{}) ([]string, error) {
78- allRows := [][]string{[]string{}}
79- for _, g := range i.getters {
80- newRows := [][]string{}
81- keys := g.get(obj)
82- if len(keys) == 0 {
83- return []string{}, nil
84- }
85- for _,key := range keys {
86- for _, row := range allRows {
87- newRows = append(newRows, append(row, key.(string)))
88- }
89- }
90- allRows = newRows
91- }
92- result := []string{}
93- for _, row := range allRows {
94- result = append(result, strings.Join(row, "\x01"))
95- }
96- return result, nil
97+ allRows := [][]string{[]string{}}
98+ for _, g := range i.getters {
99+ newRows := [][]string{}
100+ keys := g.get(obj)
101+ if len(keys) == 0 {
102+ return []string{}, nil
103+ }
104+ for _, key := range keys {
105+ for _, row := range allRows {
106+ newRows = append(newRows, append(row, key.(string)))
107+ }
108+ }
109+ allRows = newRows
110+ }
111+ result := []string{}
112+ for _, row := range allRows {
113+ result = append(result, strings.Join(row, "\x01"))
114+ }
115+ return result, nil
116 }
117
118 func (i *InMemoryIndex) addJson(docId string, doc []byte) error {
119- keys, err := i.evaluateJson(doc)
120- if err != nil {
121- return err
122- }
123- if len(keys) == 0 {
124- return nil
125- }
126- for _, key := range keys {
127- v, ok := i.values[key]
128- if !ok {
129- v := make(map[string]int)
130- v[docId] = 0
131- i.values[key] = &v
132- } else {
133- (*v)[docId] = 0
134- }
135- }
136- return nil
137+ keys, err := i.evaluateJson(doc)
138+ if err != nil {
139+ return err
140+ }
141+ if len(keys) == 0 {
142+ return nil
143+ }
144+ for _, key := range keys {
145+ v, ok := i.values[key]
146+ if !ok {
147+ v := make(map[string]int)
148+ v[docId] = 0
149+ i.values[key] = &v
150+ } else {
151+ (*v)[docId] = 0
152+ }
153+ }
154+ return nil
155 }
156
157 func (i *InMemoryIndex) removeJson(docId string, doc []byte) error {
158- keys, err := i.evaluateJson(doc)
159- if err != nil {
160- return err
161- }
162- if len(keys) == 0 {
163- return nil
164- }
165- for _, key := range keys {
166- v, ok := i.values[key]
167- if !ok {
168- continue
169- }
170- delete(*v, docId)
171- if len(*i.values[key]) == 0 {
172- delete(i.values, key)
173- }
174- }
175- return nil
176+ keys, err := i.evaluateJson(doc)
177+ if err != nil {
178+ return err
179+ }
180+ if len(keys) == 0 {
181+ return nil
182+ }
183+ for _, key := range keys {
184+ v, ok := i.values[key]
185+ if !ok {
186+ continue
187+ }
188+ delete(*v, docId)
189+ if len(*i.values[key]) == 0 {
190+ delete(i.values, key)
191+ }
192+ }
193+ return nil
194 }
195
196 func (i *InMemoryIndex) keys() []string {
197- keys := []string{}
198- for key, _ := range i.values {
199- keys = append(keys, key)
200- }
201- return keys
202+ keys := []string{}
203+ for key, _ := range i.values {
204+ keys = append(keys, key)
205+ }
206+ return keys
207 }
208
209 func (i *InMemoryIndex) findNonWildCards(keys []string) (int, error) {
210- if len(keys) != len(i.definition) {
211- return 0, InvalidValueForIndex{"Invalid value for index."}
212- }
213- isWildcard := false
214- last := 0
215- for idx, val := range keys {
216- if val[len(val)-1] == '*' {
217- if val != "*" {
218- if isWildcard {
219- return 0, InvalidValueForIndex{"Invalid globbing."}
220- }
221- last = idx + 1
222- }
223- isWildcard = true
224- } else {
225- if isWildcard {
226- return 0, InvalidValueForIndex{"Invalid globbing."}
227- }
228- last = idx + 1
229- }
230- }
231- if !isWildcard {
232- return -1, nil
233- }
234- return last, nil
235+ if len(keys) != len(i.definition) {
236+ return 0, InvalidValueForIndex{"Invalid value for index."}
237+ }
238+ isWildcard := false
239+ last := 0
240+ for idx, val := range keys {
241+ if val[len(val)-1] == '*' {
242+ if val != "*" {
243+ if isWildcard {
244+ return 0, InvalidValueForIndex{"Invalid globbing."}
245+ }
246+ last = idx + 1
247+ }
248+ isWildcard = true
249+ } else {
250+ if isWildcard {
251+ return 0, InvalidValueForIndex{"Invalid globbing."}
252+ }
253+ last = idx + 1
254+ }
255+ }
256+ if !isWildcard {
257+ return -1, nil
258+ }
259+ return last, nil
260 }
261
262 func (i *InMemoryIndex) lookupExact(keys []string) []string {
263- key := strings.Join(keys, "\x01")
264- value, ok := i.values[key]
265- if !ok {
266- return []string{}
267- }
268- docIds := []string{}
269- for key, _ := range *value {
270- docIds = append(docIds, key)
271- }
272- return docIds
273+ key := strings.Join(keys, "\x01")
274+ value, ok := i.values[key]
275+ if !ok {
276+ return []string{}
277+ }
278+ docIds := []string{}
279+ for key, _ := range *value {
280+ docIds = append(docIds, key)
281+ }
282+ return docIds
283 }
284
285 func getPrefix(keys []string) string {
286- keyPrefix := strings.Join(keys, "\x01")
287- return strings.TrimRight(keyPrefix, "*")
288+ keyPrefix := strings.Join(keys, "\x01")
289+ return strings.TrimRight(keyPrefix, "*")
290 }
291
292 func (i *InMemoryIndex) lookupPrefix(keys []string) []string {
293- keyPrefix := getPrefix(keys)
294- allDocIds := []string{}
295- for key, value := range i.values {
296- if strings.HasPrefix(key, keyPrefix) {
297- docIds := []string{}
298- for key, _ := range *value {
299- docIds = append(docIds, key)
300- }
301- allDocIds = append(allDocIds, docIds...)
302- }
303- }
304- return allDocIds
305+ keyPrefix := getPrefix(keys)
306+ allDocIds := []string{}
307+ for key, value := range i.values {
308+ if strings.HasPrefix(key, keyPrefix) {
309+ docIds := []string{}
310+ for key, _ := range *value {
311+ docIds = append(docIds, key)
312+ }
313+ allDocIds = append(allDocIds, docIds...)
314+ }
315+ }
316+ return allDocIds
317 }
318
319 func (i *InMemoryIndex) lookup(keys []string) ([]string, error) {
320- last, err := i.findNonWildCards(keys)
321- if err != nil {
322- return nil, err
323- }
324- if last == -1 {
325- return i.lookupExact(keys), nil
326- }
327- return i.lookupPrefix(keys[:last]), nil
328+ last, err := i.findNonWildCards(keys)
329+ if err != nil {
330+ return nil, err
331+ }
332+ if last == -1 {
333+ return i.lookupExact(keys), nil
334+ }
335+ return i.lookupPrefix(keys[:last]), nil
336 }
337
338 func NewInMemoryIndex(name string, definition []string) *InMemoryIndex {
339- parser := NewQueryParser()
340- getters, _ := parser.parseAll(definition)
341- values := make(map[string]*map[string]int)
342- return &InMemoryIndex{name, definition, parser, getters, values}
343+ parser := NewQueryParser()
344+ getters, _ := parser.parseAll(definition)
345+ values := make(map[string]*map[string]int)
346+ return &InMemoryIndex{name, definition, parser, getters, values}
347 }

Subscribers

People subscribed via source and target branches

to all changes: