20.5 KB
golang-github-julienschmidt-httprouter version 1.3.0-1~jan+unchanged1 (unchanged) vs.
golang-github-julienschmidt-httprouter version 1.3.0+git20200921.1.fe77dd0-1~jan+nus1 (fresh-snapshots)
20.3 KB
golang-github-julienschmidt-httprouter-dev_1.3.0+git20200921.1.fe77dd0-1_all.deb
452 B
file list
    
Offset 1, 3 lines modifiedOffset 1, 3 lines modified
1 -rw-r--r--···0········0········0········4·2021-01-16·20:24:04.000000·debian-binary1 -rw-r--r--···0········0········0········4·2021-01-16·20:24:04.000000·debian-binary
2 -rw-r--r--···0········0········0·····1116·2021-01-16·20:24:04.000000·control.tar.xz2 -rw-r--r--···0········0········0·····1128·2021-01-16·20:24:04.000000·control.tar.xz
3 -rw-r--r--···0········0········0····18112·2021-01-16·20:24:04.000000·data.tar.xz3 -rw-r--r--···0········0········0····19460·2021-01-16·20:24:04.000000·data.tar.xz
1.07 KB
control.tar.xz
1.04 KB
control.tar
411 B
file list
    
Offset 1, 3 lines modifiedOffset 1, 3 lines modified
1 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./1 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./
2 -rw-r--r--···0·root·········(0)·root·········(0)·····1026·2021-01-16·20:24:04.000000·./control2 -rw-r--r--···0·root·········(0)·root·········(0)·····1042·2021-01-16·20:24:04.000000·./control
3 -rw-r--r--···0·root·········(0)·root·········(0)······923·2021-01-16·20:24:04.000000·./md5sums3 -rw-r--r--···0·root·········(0)·root·········(0)······923·2021-01-16·20:24:04.000000·./md5sums
637 B
./control
    
Offset 1, 13 lines modifiedOffset 1, 13 lines modified
1 Package:·golang-github-julienschmidt-httprouter-dev1 Package:·golang-github-julienschmidt-httprouter-dev
2 Source:·golang-github-julienschmidt-httprouter2 Source:·golang-github-julienschmidt-httprouter
3 Version:·1.3.0+git20200921.1.fe77dd0-13 Version:·1.3.0+git20200921.1.fe77dd0-1
4 Architecture:·all4 Architecture:·all
5 Maintainer:·Debian·Go·Packaging·Team·<team+pkg-go@tracker.debian.org>5 Maintainer:·Debian·Go·Packaging·Team·<team+pkg-go@tracker.debian.org>
6 Installed-Size:·876 Installed-Size:·94
7 Breaks:·burrow·(<<·1.2.1-2)7 Breaks:·burrow·(<<·1.2.1-2)
8 Section:·golang8 Section:·golang
9 Priority:·optional9 Priority:·optional
10 Multi-Arch:·foreign10 Multi-Arch:·foreign
11 Homepage:·https://github.com/julienschmidt/httprouter11 Homepage:·https://github.com/julienschmidt/httprouter
12 Description:·High·performance·HTTP·request·router·for·Go·that·scales·well12 Description:·High·performance·HTTP·request·router·for·Go·that·scales·well
13 ·HttpRouter·(github.com/julienschmidt/httprouter)·is·a·lightweight·high13 ·HttpRouter·(github.com/julienschmidt/httprouter)·is·a·lightweight·high
18.7 KB
data.tar.xz
18.6 KB
data.tar
3.61 KB
file list
    
Offset 1, 19 lines modifiedOffset 1, 19 lines modified
1 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./1 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./
2 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/2 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/
3 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/3 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/
4 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/doc/4 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/doc/
5 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/5 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/
6 -rw-r--r--···0·root·········(0)·root·········(0)·····1092·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/changelog.Debian.gz6 -rw-r--r--···0·root·········(0)·root·········(0)·····1123·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/changelog.Debian.gz
7 -rw-r--r--···0·root·········(0)·root·········(0)·····1800·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/copyright7 -rw-r--r--···0·root·········(0)·root·········(0)·····1800·2021-01-16·20:24:04.000000·./usr/share/doc/golang-github-julienschmidt-httprouter-dev/copyright
8 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/8 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/
9 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/9 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/
10 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/10 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/
11 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/11 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/
12 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/12 drwxr-xr-x···0·root·········(0)·root·········(0)········0·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/
13 -rw-r--r--···0·root·········(0)·root·········(0)·······51·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/go.mod13 -rw-r--r--···0·root·········(0)·root·········(0)·······51·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/go.mod
14 -rw-r--r--···0·root·········(0)·root·········(0)·····2671·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/path.go14 -rw-r--r--···0·root·········(0)·root·········(0)·····3571·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/path.go
15 -rw-r--r--···0·root·········(0)·root·········(0)·····2127·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/path_test.go15 -rw-r--r--···0·root·········(0)·root·········(0)·····3269·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/path_test.go
16 -rw-r--r--···0·root·········(0)·root·········(0)····14900·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/router.go16 -rw-r--r--···0·root·········(0)·root·········(0)····17147·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/router.go
17 -rw-r--r--···0·root·········(0)·root·········(0)····16292·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/router_test.go17 -rw-r--r--···0·root·········(0)·root·········(0)····18984·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/router_test.go
18 -rw-r--r--···0·root·········(0)·root·········(0)····16649·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree.go18 -rw-r--r--···0·root·········(0)·root·········(0)····16645·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree.go
19 -rw-r--r--···0·root·········(0)·root·········(0)····17047·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree_test.go19 -rw-r--r--···0·root·········(0)·root·········(0)····16823·2021-01-16·20:24:04.000000·./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree_test.go
790 B
./usr/share/doc/golang-github-julienschmidt-httprouter-dev/changelog.Debian.gz
634 B
changelog.Debian
    
Offset 1, 12 lines modifiedOffset 1, 13 lines modified
1 golang-github-julienschmidt-httprouter·(1.3.0+git20200921.1.fe77dd0-1)·unchanged;·urgency=low1 golang-github-julienschmidt-httprouter·(1.3.0+git20200921.1.fe77dd0-1)·fresh-snapshots;·urgency=low
  
 2 ··*·New·upstream·snapshot.
2 ··*·Build·for·debian-janitor·apt·repository.3 ··*·Build·for·debian-janitor·apt·repository.
  
3 ·--·Debian·Janitor·<janitor@jelmer.uk>··Fri,·09·Apr·2021·23:44:19·-00004 ·--·Debian·Janitor·<janitor@jelmer.uk>··Fri,·09·Apr·2021·22:02:29·-0000
  
4 golang-github-julienschmidt-httprouter·(1.3.0-1)·unstable;·urgency=medium5 golang-github-julienschmidt-httprouter·(1.3.0-1)·unstable;·urgency=medium
  
5 ··*·Team·upload.6 ··*·Team·upload.
  
6 ··[·Alexandre·Viau·]7 ··[·Alexandre·Viau·]
7 ··*·Point·Vcs-*·urls·to·salsa.debian.org.8 ··*·Point·Vcs-*·urls·to·salsa.debian.org.
1.93 KB
./usr/share/gocode/src/github.com/julienschmidt/httprouter/path.go
    
Offset 65, 59 lines modifiedOffset 76, 75 lines modified
65 »       »       »       //·..·element:·remove·to·last·/76 »       »       »       //·..·element:·remove·to·last·/
66 »       »       »       r·+=·377 »       »       »       r·+=·3
  
67 »       »       »       if·w·>·1·{78 »       »       »       if·w·>·1·{
68 »       »       »       »       //·can·backtrack79 »       »       »       »       //·can·backtrack
69 »       »       »       »       w--80 »       »       »       »       w--
  
70 »       »       »       »       if·buf·==·nil·{81 »       »       »       »       if·len(buf)·==·0·{
71 »       »       »       »       »       for·w·>·1·&&·p[w]·!=·'/'·{82 »       »       »       »       »       for·w·>·1·&&·p[w]·!=·'/'·{
72 »       »       »       »       »       »       w--83 »       »       »       »       »       »       w--
73 »       »       »       »       »       }84 »       »       »       »       »       }
74 »       »       »       »       }·else·{85 »       »       »       »       }·else·{
75 »       »       »       »       »       for·w·>·1·&&·buf[w]·!=·'/'·{86 »       »       »       »       »       for·w·>·1·&&·buf[w]·!=·'/'·{
76 »       »       »       »       »       »       w--87 »       »       »       »       »       »       w--
77 »       »       »       »       »       }88 »       »       »       »       »       }
78 »       »       »       »       }89 »       »       »       »       }
79 »       »       »       }90 »       »       »       }
  
80 »       »       default:91 »       »       default:
81 »       »       »       //·real·path·element.92 »       »       »       //·Real·path·element.
82 »       »       »       //·add·slash·if·needed93 »       »       »       //·Add·slash·if·needed
83 »       »       »       if·w·>·1·{94 »       »       »       if·w·>·1·{
84 »       »       »       »       bufApp(&buf,·p,·w,·'/')95 »       »       »       »       bufApp(&buf,·p,·w,·'/')
85 »       »       »       »       w++96 »       »       »       »       w++
86 »       »       »       }97 »       »       »       }
  
87 »       »       »       //·copy·element98 »       »       »       //·Copy·element
88 »       »       »       for·r·<·n·&&·p[r]·!=·'/'·{99 »       »       »       for·r·<·n·&&·p[r]·!=·'/'·{
89 »       »       »       »       bufApp(&buf,·p,·w,·p[r])100 »       »       »       »       bufApp(&buf,·p,·w,·p[r])
90 »       »       »       »       w++101 »       »       »       »       w++
91 »       »       »       »       r++102 »       »       »       »       r++
92 »       »       »       }103 »       »       »       }
93 »       »       }104 »       »       }
94 »       }105 »       }
  
95 »       //·re-append·trailing·slash106 »       //·Re-append·trailing·slash
96 »       if·trailing·&&·w·>·1·{107 »       if·trailing·&&·w·>·1·{
97 »       »       bufApp(&buf,·p,·w,·'/')108 »       »       bufApp(&buf,·p,·w,·'/')
98 »       »       w++109 »       »       w++
99 »       }110 »       }
  
100 »       if·buf·==·nil·{111 »       //·If·the·original·string·was·not·modified·(or·only·shortened·at·the·end),
 112 »       //·return·the·respective·substring·of·the·original·string.
 113 »       //·Otherwise·return·a·new·string·from·the·buffer.
 114 »       if·len(buf)·==·0·{
101 »       »       return·p[:w]115 »       »       return·p[:w]
102 »       }116 »       }
103 »       return·string(buf[:w])117 »       return·string(buf[:w])
104 }118 }
  
105 //·internal·helper·to·lazily·create·a·buffer·if·necessary119 //·Internal·helper·to·lazily·create·a·buffer·if·necessary.
 120 //·Calls·to·this·function·get·inlined.
106 func·bufApp(buf·*[]byte,·s·string,·w·int,·c·byte)·{121 func·bufApp(buf·*[]byte,·s·string,·w·int,·c·byte)·{
107 »       if·*buf·==·nil·{122 »       b·:=·*buf
 123 »       if·len(b)·==·0·{
 124 »       »       //·No·modification·of·the·original·string·so·far.
 125 »       »       //·If·the·next·character·is·the·same·as·in·the·original·string,·we·do
 126 »       »       //·not·yet·have·to·allocate·a·buffer.
108 »       »       if·s[w]·==·c·{127 »       »       if·s[w]·==·c·{
109 »       »       »       return128 »       »       »       return
110 »       »       }129 »       »       }
  
 130 »       »       //·Otherwise·use·either·the·stack·buffer,·if·it·is·large·enough,·or
 131 »       »       //·allocate·a·new·buffer·on·the·heap,·and·copy·all·previous·characters.
 132 »       »       if·l·:=·len(s);·l·>·cap(b)·{
111 »       »       *buf·=·make([]byte,·len(s))133 »       »       »       *buf·=·make([]byte,·len(s))
 134 »       »       }·else·{
 135 »       »       »       *buf·=·(*buf)[:l]
 136 »       »       }
 137 »       »       b·=·*buf
  
112 »       »       copy(*buf,·s[:w])138 »       »       copy(b,·s[:w])
113 »       }139 »       }
114 »       (*buf)[w]·=·c140 »       b[w]·=·c
115 }141 }
1.83 KB
./usr/share/gocode/src/github.com/julienschmidt/httprouter/path_test.go
    
Offset 75, 19 lines modifiedOffset 77, 73 lines modified
75 »       }77 »       }
76 }78 }
  
77 func·TestPathCleanMallocs(t·*testing.T)·{79 func·TestPathCleanMallocs(t·*testing.T)·{
78 »       if·testing.Short()·{80 »       if·testing.Short()·{
79 »       »       t.Skip("skipping·malloc·count·in·short·mode")81 »       »       t.Skip("skipping·malloc·count·in·short·mode")
80 »       }82 »       }
81 »       if·runtime.GOMAXPROCS(0)·>·1·{ 
82 »       »       t.Log("skipping·AllocsPerRun·checks;·GOMAXPROCS>1") 
83 »       »       return 
84 »       } 
  
85 »       for·_,·test·:=·range·cleanTests·{83 »       for·_,·test·:=·range·cleanTests·{
 84 »       »       test·:=·test
86 »       »       allocs·:=·testing.AllocsPerRun(100,·func()·{·CleanPath(test.result)·})85 »       »       allocs·:=·testing.AllocsPerRun(100,·func()·{·CleanPath(test.result)·})
87 »       »       if·allocs·>·0·{86 »       »       if·allocs·>·0·{
88 »       »       »       t.Errorf("CleanPath(%q):·%v·allocs,·want·zero",·test.result,·allocs)87 »       »       »       t.Errorf("CleanPath(%q):·%v·allocs,·want·zero",·test.result,·allocs)
89 »       »       }88 »       »       }
90 »       }89 »       }
91 }90 }
  
 91 func·BenchmarkPathClean(b·*testing.B)·{
 92 »       b.ReportAllocs()
  
 93 »       for·i·:=·0;·i·<·b.N;·i++·{
 94 »       »       for·_,·test·:=·range·cleanTests·{
 95 »       »       »       CleanPath(test.path)
 96 »       »       }
 97 »       }
 98 }
  
 99 func·genLongPaths()·(testPaths·[]cleanPathTest)·{
 100 »       for·i·:=·1;·i·<=·1234;·i++·{
 101 »       »       ss·:=·strings.Repeat("a",·i)
  
 102 »       »       correctPath·:=·"/"·+·ss
 103 »       »       testPaths·=·append(testPaths,·cleanPathTest{
 104 »       »       »       path:···correctPath,
 105 »       »       »       result:·correctPath,
 106 »       »       },·cleanPathTest{
 107 »       »       »       path:···ss,
 108 »       »       »       result:·correctPath,
 109 »       »       },·cleanPathTest{
 110 »       »       »       path:···"//"·+·ss,
 111 »       »       »       result:·correctPath,
 112 »       »       },·cleanPathTest{
 113 »       »       »       path:···"/"·+·ss·+·"/b/..",
 114 »       »       »       result:·correctPath,
 115 »       »       })
 116 »       }
 117 »       return·testPaths
 118 }
  
 119 func·TestPathCleanLong(t·*testing.T)·{
 120 »       cleanTests·:=·genLongPaths()
  
 121 »       for·_,·test·:=·range·cleanTests·{
 122 »       »       if·s·:=·CleanPath(test.path);·s·!=·test.result·{
 123 »       »       »       t.Errorf("CleanPath(%q)·=·%q,·want·%q",·test.path,·s,·test.result)
 124 »       »       }
 125 »       »       if·s·:=·CleanPath(test.result);·s·!=·test.result·{
 126 »       »       »       t.Errorf("CleanPath(%q)·=·%q,·want·%q",·test.result,·s,·test.result)
 127 »       »       }
 128 »       }
 129 }
  
 130 func·BenchmarkPathCleanLong(b·*testing.B)·{
 131 »       cleanTests·:=·genLongPaths()
 132 »       b.ResetTimer()
 133 »       b.ReportAllocs()
  
 134 »       for·i·:=·0;·i·<·b.N;·i++·{
 135 »       »       for·_,·test·:=·range·cleanTests·{
 136 »       »       »       CleanPath(test.path)
 137 »       »       }
 138 »       }
 139 }
513 B
./usr/share/gocode/src/github.com/julienschmidt/httprouter/router.go
    
Offset 407, 15 lines modifiedOffset 495, 15 lines modified
407 »       »       »       //·Try·to·fix·the·request·path495 »       »       »       //·Try·to·fix·the·request·path
408 »       »       »       if·r.RedirectFixedPath·{496 »       »       »       if·r.RedirectFixedPath·{
409 »       »       »       »       fixedPath,·found·:=·root.findCaseInsensitivePath(497 »       »       »       »       fixedPath,·found·:=·root.findCaseInsensitivePath(
410 »       »       »       »       »       CleanPath(path),498 »       »       »       »       »       CleanPath(path),
411 »       »       »       »       »       r.RedirectTrailingSlash,499 »       »       »       »       »       r.RedirectTrailingSlash,
412 »       »       »       »       )500 »       »       »       »       )
413 »       »       »       »       if·found·{501 »       »       »       »       if·found·{
414 »       »       »       »       »       req.URL.Path·=·string(fixedPath)502 »       »       »       »       »       req.URL.Path·=·fixedPath
415 »       »       »       »       »       http.Redirect(w,·req,·req.URL.String(),·code)503 »       »       »       »       »       http.Redirect(w,·req,·req.URL.String(),·code)
416 »       »       »       »       »       return504 »       »       »       »       »       return
417 »       »       »       »       }505 »       »       »       »       }
418 »       »       »       }506 »       »       »       }
419 »       »       }507 »       »       }
420 »       }508 »       }
  
2.05 KB
./usr/share/gocode/src/github.com/julienschmidt/httprouter/router_test.go
    
Offset 568, 14 lines modifiedOffset 606, 73 lines modified
568 »       r,·_·=·http.NewRequest(http.MethodGet,·"/user",·nil)606 »       r,·_·=·http.NewRequest(http.MethodGet,·"/user",·nil)
569 »       router.ServeHTTP(w,·r)607 »       router.ServeHTTP(w,·r)
570 »       if·!routed·{608 »       if·!routed·{
571 »       »       t.Fatal("Routing·failed!")609 »       »       t.Fatal("Routing·failed!")
572 »       }610 »       }
573 }611 }
  
 612 func·TestRouterMatchedRoutePath(t·*testing.T)·{
 613 »       route1·:=·"/user/:name"
 614 »       routed1·:=·false
 615 »       handle1·:=·func(_·http.ResponseWriter,·req·*http.Request,·ps·Params)·{
 616 »       »       route·:=·ps.MatchedRoutePath()
 617 »       »       if·route·!=·route1·{
 618 »       »       »       t.Fatalf("Wrong·matched·route:·want·%s,·got·%s",·route1,·route)
 619 »       »       }
 620 »       »       routed1·=·true
 621 »       }
  
 622 »       route2·:=·"/user/:name/details"
 623 »       routed2·:=·false
 624 »       handle2·:=·func(_·http.ResponseWriter,·req·*http.Request,·ps·Params)·{
 625 »       »       route·:=·ps.MatchedRoutePath()
 626 »       »       if·route·!=·route2·{
 627 »       »       »       t.Fatalf("Wrong·matched·route:·want·%s,·got·%s",·route2,·route)
 628 »       »       }
 629 »       »       routed2·=·true
 630 »       }
  
 631 »       route3·:=·"/"
 632 »       routed3·:=·false
 633 »       handle3·:=·func(_·http.ResponseWriter,·req·*http.Request,·ps·Params)·{
 634 »       »       route·:=·ps.MatchedRoutePath()
 635 »       »       if·route·!=·route3·{
 636 »       »       »       t.Fatalf("Wrong·matched·route:·want·%s,·got·%s",·route3,·route)
 637 »       »       }
 638 »       »       routed3·=·true
 639 »       }
  
 640 »       router·:=·New()
 641 »       router.SaveMatchedRoutePath·=·true
 642 »       router.Handle(http.MethodGet,·route1,·handle1)
 643 »       router.Handle(http.MethodGet,·route2,·handle2)
 644 »       router.Handle(http.MethodGet,·route3,·handle3)
  
 645 »       w·:=·new(mockResponseWriter)
 646 »       r,·_·:=·http.NewRequest(http.MethodGet,·"/user/gopher",·nil)
 647 »       router.ServeHTTP(w,·r)
 648 »       if·!routed1·||·routed2·||·routed3·{
 649 »       »       t.Fatal("Routing·failed!")
 650 »       }
  
 651 »       w·=·new(mockResponseWriter)
 652 »       r,·_·=·http.NewRequest(http.MethodGet,·"/user/gopher/details",·nil)
 653 »       router.ServeHTTP(w,·r)
 654 »       if·!routed2·||·routed3·{
 655 »       »       t.Fatal("Routing·failed!")
 656 »       }
  
 657 »       w·=·new(mockResponseWriter)
 658 »       r,·_·=·http.NewRequest(http.MethodGet,·"/",·nil)
 659 »       router.ServeHTTP(w,·r)
 660 »       if·!routed3·{
 661 »       »       t.Fatal("Routing·failed!")
 662 »       }
 663 }
  
574 type·mockFileSystem·struct·{664 type·mockFileSystem·struct·{
575 »       opened·bool665 »       opened·bool
576 }666 }
  
577 func·(mfs·*mockFileSystem)·Open(name·string)·(http.File,·error)·{667 func·(mfs·*mockFileSystem)·Open(name·string)·(http.File,·error)·{
578 »       mfs.opened·=·true668 »       mfs.opened·=·true
579 »       return·nil,·errors.New("this·is·just·a·mock")669 »       return·nil,·errors.New("this·is·just·a·mock")
6.89 KB
./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree.go
    
Offset 484, 183 lines modifiedOffset 493, 188 lines modified
484 »       case·3:493 »       case·3:
485 »       »       return·[4]byte{rb[3]}494 »       »       return·[4]byte{rb[3]}
486 »       default:495 »       default:
487 »       »       return·[4]byte{}496 »       »       return·[4]byte{}
488 »       }497 »       }
489 }498 }
  
490 //·recursive·case-insensitive·lookup·function·used·by·n.findCaseInsensitivePath499 //·Recursive·case-insensitive·lookup·function·used·by·n.findCaseInsensitivePath
491 func·(n·*node)·findCaseInsensitivePathRec(path·string,·ciPath·[]byte,·rb·[4]byte,·fixTrailingSlash·bool)·([]byte,·bool)·{500 func·(n·*node)·findCaseInsensitivePathRec(path·string,·ciPath·[]byte,·rb·[4]byte,·fixTrailingSlash·bool)·[]byte·{
492 »       npLen·:=·len(n.path)501 »       npLen·:=·len(n.path)
  
493 walk:·//·outer·loop·for·walking·the·tree502 walk:·//·Outer·loop·for·walking·the·tree
494 »       for·len(path)·>=·npLen·&&·(npLen·==·0·||·strings.EqualFold(path[1:npLen],·n.path[1:]))·{503 »       for·len(path)·>=·npLen·&&·(npLen·==·0·||·strings.EqualFold(path[1:npLen],·n.path[1:]))·{
495 »       »       //·add·common·prefix·to·result504 »       »       //·Add·common·prefix·to·result
  
496 »       »       oldPath·:=·path505 »       »       oldPath·:=·path
497 »       »       path·=·path[npLen:]506 »       »       path·=·path[npLen:]
498 »       »       ciPath·=·append(ciPath,·n.path...)507 »       »       ciPath·=·append(ciPath,·n.path...)
  
499 »       »       if·len(path)·>·0·{508 »       »       if·len(path)·>·0·{
500 »       »       »       //·If·this·node·does·not·have·a·wildcard·(param·or·catchAll)·child,509 »       »       »       //·If·this·node·does·not·have·a·wildcard·(param·or·catchAll)·child,
501 »       »       »       //·we·can·just·look·up·the·next·child·node·and·continue·to·walk·down510 »       »       »       //·we·can·just·look·up·the·next·child·node·and·continue·to·walk·down
502 »       »       »       //·the·tree511 »       »       »       //·the·tree
503 »       »       »       if·!n.wildChild·{512 »       »       »       if·!n.wildChild·{
504 »       »       »       »       //·skip·rune·bytes·already·processed513 »       »       »       »       //·Skip·rune·bytes·already·processed
505 »       »       »       »       rb·=·shiftNRuneBytes(rb,·npLen)514 »       »       »       »       rb·=·shiftNRuneBytes(rb,·npLen)
  
506 »       »       »       »       if·rb[0]·!=·0·{515 »       »       »       »       if·rb[0]·!=·0·{
507 »       »       »       »       »       //·old·rune·not·finished516 »       »       »       »       »       //·Old·rune·not·finished
508 »       »       »       »       »       for·i·:=·0;·i·<·len(n.indices);·i++·{ 
509 »       »       »       »       »       »       if·n.indices[i]·==·rb[0]·{517 »       »       »       »       »       idxc·:=·rb[0]
 518 »       »       »       »       »       for·i,·c·:=·range·[]byte(n.indices)·{
 519 »       »       »       »       »       »       if·c·==·idxc·{
510 »       »       »       »       »       »       »       //·continue·with·child·node520 »       »       »       »       »       »       »       //·continue·with·child·node
511 »       »       »       »       »       »       »       n·=·n.children[i]521 »       »       »       »       »       »       »       n·=·n.children[i]
512 »       »       »       »       »       »       »       npLen·=·len(n.path)522 »       »       »       »       »       »       »       npLen·=·len(n.path)
513 »       »       »       »       »       »       »       continue·walk523 »       »       »       »       »       »       »       continue·walk
514 »       »       »       »       »       »       }524 »       »       »       »       »       »       }
515 »       »       »       »       »       }525 »       »       »       »       »       }
516 »       »       »       »       }·else·{526 »       »       »       »       }·else·{
517 »       »       »       »       »       //·process·a·new·rune527 »       »       »       »       »       //·Process·a·new·rune
518 »       »       »       »       »       var·rv·rune528 »       »       »       »       »       var·rv·rune
  
519 »       »       »       »       »       //·find·rune·start529 »       »       »       »       »       //·Find·rune·start.
520 »       »       »       »       »       //·runes·are·up·to·4·byte·long,530 »       »       »       »       »       //·Runes·are·up·to·4·byte·long,
521 »       »       »       »       »       //·-4·would·definitely·be·another·rune531 »       »       »       »       »       //·-4·would·definitely·be·another·rune.
522 »       »       »       »       »       var·off·int532 »       »       »       »       »       var·off·int
523 »       »       »       »       »       for·max·:=·min(npLen,·3);·off·<·max;·off++·{533 »       »       »       »       »       for·max·:=·min(npLen,·3);·off·<·max;·off++·{
524 »       »       »       »       »       »       if·i·:=·npLen·-·off;·utf8.RuneStart(oldPath[i])·{534 »       »       »       »       »       »       if·i·:=·npLen·-·off;·utf8.RuneStart(oldPath[i])·{
525 »       »       »       »       »       »       »       //·read·rune·from·cached·path535 »       »       »       »       »       »       »       //·read·rune·from·cached·path
526 »       »       »       »       »       »       »       rv,·_·=·utf8.DecodeRuneInString(oldPath[i:])536 »       »       »       »       »       »       »       rv,·_·=·utf8.DecodeRuneInString(oldPath[i:])
527 »       »       »       »       »       »       »       break537 »       »       »       »       »       »       »       break
528 »       »       »       »       »       »       }538 »       »       »       »       »       »       }
529 »       »       »       »       »       }539 »       »       »       »       »       }
  
530 »       »       »       »       »       //·calculate·lowercase·bytes·of·current·rune540 »       »       »       »       »       //·Calculate·lowercase·bytes·of·current·rune
531 »       »       »       »       »       lo·:=·unicode.ToLower(rv)541 »       »       »       »       »       lo·:=·unicode.ToLower(rv)
532 »       »       »       »       »       utf8.EncodeRune(rb[:],·lo)542 »       »       »       »       »       utf8.EncodeRune(rb[:],·lo)
  
533 »       »       »       »       »       //·skip·already·processed·bytes543 »       »       »       »       »       //·Skip·already·processed·bytes
534 »       »       »       »       »       rb·=·shiftNRuneBytes(rb,·off)544 »       »       »       »       »       rb·=·shiftNRuneBytes(rb,·off)
  
535 »       »       »       »       »       for·i·:=·0;·i·<·len(n.indices);·i++·{545 »       »       »       »       »       idxc·:=·rb[0]
 546 »       »       »       »       »       for·i,·c·:=·range·[]byte(n.indices)·{
536 »       »       »       »       »       »       //·lowercase·matches547 »       »       »       »       »       »       //·Lowercase·matches
537 »       »       »       »       »       »       if·n.indices[i]·==·rb[0]·{548 »       »       »       »       »       »       if·c·==·idxc·{
538 »       »       »       »       »       »       »       //·must·use·a·recursive·approach·since·both·the549 »       »       »       »       »       »       »       //·must·use·a·recursive·approach·since·both·the
539 »       »       »       »       »       »       »       //·uppercase·byte·and·the·lowercase·byte·might·exist550 »       »       »       »       »       »       »       //·uppercase·byte·and·the·lowercase·byte·might·exist
540 »       »       »       »       »       »       »       //·as·an·index551 »       »       »       »       »       »       »       //·as·an·index
541 »       »       »       »       »       »       »       if·out,·found·:=·n.children[i].findCaseInsensitivePathRec(552 »       »       »       »       »       »       »       if·out·:=·n.children[i].findCaseInsensitivePathRec(
542 »       »       »       »       »       »       »       »       path,·ciPath,·rb,·fixTrailingSlash,553 »       »       »       »       »       »       »       »       path,·ciPath,·rb,·fixTrailingSlash,
543 »       »       »       »       »       »       »       );·found·{554 »       »       »       »       »       »       »       );·out·!=·nil·{
544 »       »       »       »       »       »       »       »       return·out,·true555 »       »       »       »       »       »       »       »       return·out
545 »       »       »       »       »       »       »       }556 »       »       »       »       »       »       »       }
546 »       »       »       »       »       »       »       break557 »       »       »       »       »       »       »       break
547 »       »       »       »       »       »       }558 »       »       »       »       »       »       }
548 »       »       »       »       »       }559 »       »       »       »       »       }
  
549 »       »       »       »       »       //·if·we·found·no·match,·the·same·for·the·uppercase·rune,560 »       »       »       »       »       //·If·we·found·no·match,·the·same·for·the·uppercase·rune,
550 »       »       »       »       »       //·if·it·differs561 »       »       »       »       »       //·if·it·differs
551 »       »       »       »       »       if·up·:=·unicode.ToUpper(rv);·up·!=·lo·{562 »       »       »       »       »       if·up·:=·unicode.ToUpper(rv);·up·!=·lo·{
552 »       »       »       »       »       »       utf8.EncodeRune(rb[:],·up)563 »       »       »       »       »       »       utf8.EncodeRune(rb[:],·up)
553 »       »       »       »       »       »       rb·=·shiftNRuneBytes(rb,·off)564 »       »       »       »       »       »       rb·=·shiftNRuneBytes(rb,·off)
  
554 »       »       »       »       »       »       for·i,·c·:=·0,·rb[0];·i·<·len(n.indices);·i++·{565 »       »       »       »       »       »       idxc·:=·rb[0]
 566 »       »       »       »       »       »       for·i,·c·:=·range·[]byte(n.indices)·{
555 »       »       »       »       »       »       »       //·uppercase·matches567 »       »       »       »       »       »       »       //·Uppercase·matches
556 »       »       »       »       »       »       »       if·n.indices[i]·==·c·{568 »       »       »       »       »       »       »       if·c·==·idxc·{
557 »       »       »       »       »       »       »       »       //·continue·with·child·node569 »       »       »       »       »       »       »       »       //·Continue·with·child·node
558 »       »       »       »       »       »       »       »       n·=·n.children[i]570 »       »       »       »       »       »       »       »       n·=·n.children[i]
559 »       »       »       »       »       »       »       »       npLen·=·len(n.path)571 »       »       »       »       »       »       »       »       npLen·=·len(n.path)
560 »       »       »       »       »       »       »       »       continue·walk572 »       »       »       »       »       »       »       »       continue·walk
561 »       »       »       »       »       »       »       }573 »       »       »       »       »       »       »       }
562 »       »       »       »       »       »       }574 »       »       »       »       »       »       }
563 »       »       »       »       »       }575 »       »       »       »       »       }
564 »       »       »       »       }576 »       »       »       »       }
  
565 »       »       »       »       //·Nothing·found.·We·can·recommend·to·redirect·to·the·same·URL577 »       »       »       »       //·Nothing·found.·We·can·recommend·to·redirect·to·the·same·URL
566 »       »       »       »       //·without·a·trailing·slash·if·a·leaf·exists·for·that·path578 »       »       »       »       //·without·a·trailing·slash·if·a·leaf·exists·for·that·path
567 »       »       »       »       return·ciPath,·(fixTrailingSlash·&&·path·==·"/"·&&·n.handle·!=·nil)579 »       »       »       »       if·fixTrailingSlash·&&·path·==·"/"·&&·n.handle·!=·nil·{
 580 »       »       »       »       »       return·ciPath
 581 »       »       »       »       }
 582 »       »       »       »       return·nil
568 »       »       »       }583 »       »       »       }
  
569 »       »       »       n·=·n.children[0]584 »       »       »       n·=·n.children[0]
570 »       »       »       switch·n.nType·{585 »       »       »       switch·n.nType·{
571 »       »       »       case·param:586 »       »       »       case·param:
572 »       »       »       »       //·find·param·end·(either·'/'·or·path·end)587 »       »       »       »       //·Find·param·end·(either·'/'·or·path·end)
573 »       »       »       »       k·:=·0588 »       »       »       »       end·:=·0
574 »       »       »       »       for·k·<·len(path)·&&·path[k]·!=·'/'·{589 »       »       »       »       for·end·<·len(path)·&&·path[end]·!=·'/'·{
575 »       »       »       »       »       k++590 »       »       »       »       »       end++
576 »       »       »       »       }591 »       »       »       »       }
  
577 »       »       »       »       //·add·param·value·to·case·insensitive·path592 »       »       »       »       //·Add·param·value·to·case·insensitive·path
578 »       »       »       »       ciPath·=·append(ciPath,·path[:k]...)593 »       »       »       »       ciPath·=·append(ciPath,·path[:end]...)
  
579 »       »       »       »       //·we·need·to·go·deeper!594 »       »       »       »       //·We·need·to·go·deeper!
580 »       »       »       »       if·k·<·len(path)·{595 »       »       »       »       if·end·<·len(path)·{
581 »       »       »       »       »       if·len(n.children)·>·0·{596 »       »       »       »       »       if·len(n.children)·>·0·{
582 »       »       »       »       »       »       //·continue·with·child·node597 »       »       »       »       »       »       //·Continue·with·child·node
583 »       »       »       »       »       »       n·=·n.children[0]598 »       »       »       »       »       »       n·=·n.children[0]
584 »       »       »       »       »       »       npLen·=·len(n.path)599 »       »       »       »       »       »       npLen·=·len(n.path)
585 »       »       »       »       »       »       path·=·path[k:]600 »       »       »       »       »       »       path·=·path[end:]
586 »       »       »       »       »       »       continue601 »       »       »       »       »       »       continue
587 »       »       »       »       »       }602 »       »       »       »       »       }
  
Max diff block lines reached; 2000/6921 bytes (28.90%) of diff not shown.
1.04 KB
./usr/share/gocode/src/github.com/julienschmidt/httprouter/tree_test.go
    
Offset 678, 26 lines modifiedOffset 668, 29 lines modified
678 »       »       {"/who/are/foo",·"/foo",·`/who/are/\*you`,·`/\*you`},668 »       »       {"/who/are/foo",·"/foo",·`/who/are/\*you`,·`/\*you`},
679 »       »       {"/who/are/foo/",·"/foo/",·`/who/are/\*you`,·`/\*you`},669 »       »       {"/who/are/foo/",·"/foo/",·`/who/are/\*you`,·`/\*you`},
680 »       »       {"/who/are/foo/bar",·"/foo/bar",·`/who/are/\*you`,·`/\*you`},670 »       »       {"/who/are/foo/bar",·"/foo/bar",·`/who/are/\*you`,·`/\*you`},
681 »       »       {"/conxxx",·"xxx",·`/con:tact`,·`:tact`},671 »       »       {"/conxxx",·"xxx",·`/con:tact`,·`:tact`},
682 »       »       {"/conooo/xxx",·"ooo",·`/con:tact`,·`:tact`},672 »       »       {"/conooo/xxx",·"ooo",·`/con:tact`,·`:tact`},
683 »       }673 »       }
  
684 »       for·_,·conflict·:=·range·conflicts·{674 »       for·i·:=·range·conflicts·{
 675 »       »       conflict·:=·conflicts[i]
  
685 »       »       //·I·have·to·re-create·a·'tree',·because·the·'tree'·will·be676 »       »       //·I·have·to·re-create·a·'tree',·because·the·'tree'·will·be
686 »       »       //·in·an·inconsistent·state·when·the·loop·recovers·from·the677 »       »       //·in·an·inconsistent·state·when·the·loop·recovers·from·the
687 »       »       //·panic·which·threw·by·'addRoute'·function.678 »       »       //·panic·which·threw·by·'addRoute'·function.
688 »       »       tree·:=·&node{}679 »       »       tree·:=·&node{}
689 »       »       routes·:=·[...]string{680 »       »       routes·:=·[...]string{
690 »       »       »       "/con:tact",681 »       »       »       "/con:tact",
691 »       »       »       "/who/are/*you",682 »       »       »       "/who/are/*you",
692 »       »       »       "/who/foo/hello",683 »       »       »       "/who/foo/hello",
693 »       »       }684 »       »       }
  
694 »       »       for·_,·route·:=·range·routes·{685 »       »       for·i·:=·range·routes·{
 686 »       »       »       route·:=·routes[i]
695 »       »       »       tree.addRoute(route,·fakeHandler(route))687 »       »       »       tree.addRoute(route,·fakeHandler(route))
696 »       »       }688 »       »       }
  
697 »       »       recv·:=·catchPanic(func()·{689 »       »       recv·:=·catchPanic(func()·{
698 »       »       »       tree.addRoute(conflict.route,·fakeHandler(conflict.route))690 »       »       »       tree.addRoute(conflict.route,·fakeHandler(conflict.route))
699 »       »       })691 »       »       })