use mixedCaps rather than underscores for function names

Author: Asim

git-http-backend.go

@@ -44,22 +44,22 @@ var config Config = Config{
 }
 
 var services =  map[string] Service {
-  "(.*?)/git-upload-pack$": Service{"POST", service_rpc, "upload-pack"},
-  "(.*?)/git-receive-pack$": Service{"POST", service_rpc, "receive-pack"},
-  "(.*?)/info/refs$": Service{"GET", get_info_refs, ""},
-  "(.*?)/HEAD$": Service{"GET", get_text_file, ""},
-  "(.*?)/objects/info/alternates$": Service{"GET", get_text_file, ""},
-  "(.*?)/objects/info/http-alternates$": Service{"GET", get_text_file, ""},
-  "(.*?)/objects/info/packs$": Service{"GET", get_info_packs, ""},
-  "(.*?)/objects/info/[^/]*$": Service{"GET", get_text_file, ""},
-  "(.*?)/objects/[0-9a-f]{2}/[0-9a-f]{38}$": Service{"GET", get_loose_object, ""},
-  "(.*?)/objects/pack/pack-[0-9a-f]{40}\\.pack$": Service{"GET", get_pack_file, ""},
-  "(.*?)/objects/pack/pack-[0-9a-f]{40}\\.idx$": Service{"GET", get_idx_file, ""},
+  "(.*?)/git-upload-pack$": Service{"POST", serviceRpc, "upload-pack"},
+  "(.*?)/git-receive-pack$": Service{"POST", serviceRpc, "receive-pack"},
+  "(.*?)/info/refs$": Service{"GET", getInfoRefs, ""},
+  "(.*?)/HEAD$": Service{"GET", getTextFile, ""},
+  "(.*?)/objects/info/alternates$": Service{"GET", getTextFile, ""},
+  "(.*?)/objects/info/http-alternates$": Service{"GET", getTextFile, ""},
+  "(.*?)/objects/info/packs$": Service{"GET", getInfoPacks, ""},
+  "(.*?)/objects/info/[^/]*$": Service{"GET", getTextFile, ""},
+  "(.*?)/objects/[0-9a-f]{2}/[0-9a-f]{38}$": Service{"GET", getLooseObject, ""},
+  "(.*?)/objects/pack/pack-[0-9a-f]{40}\\.pack$": Service{"GET", getPackFile, ""},
+  "(.*?)/objects/pack/pack-[0-9a-f]{40}\\.idx$": Service{"GET", getIdxFile, ""},
 }
 
 // Request handling function
 
-func request_handler() http.HandlerFunc {
+func requestHandler() http.HandlerFunc {
   return func(w http.ResponseWriter, r *http.Request) {
     log.Printf("%s %s %s %s", r.RemoteAddr, r.Method, r.URL.Path, r.Proto)
     for match, service := range services {
@@ -70,17 +70,17 @@ func request_handler() http.HandlerFunc {
 
       if m := re.FindStringSubmatch(r.URL.Path); m != nil {
         if service.Method != r.Method {
-          render_method_not_allowed(w, r)
+          renderMethodNotAllowed(w, r)
           return
         }
 
         rpc := service.Rpc
         file := strings.Replace(r.URL.Path, m[1] + "/", "", 1)
-        dir, err := get_git_dir(m[1])
+        dir, err := getGitDir(m[1])
 
         if err != nil {
           log.Print(err)
-          render_not_found(w)
+          renderNotFound(w)
           return
         }
 
@@ -89,19 +89,19 @@ func request_handler() http.HandlerFunc {
         return
       }
     }
-    render_not_found(w)
+    renderNotFound(w)
     return
   }
 }
 
 // Actual command handling functions
 
-func service_rpc(hr HandlerReq) {
+func serviceRpc(hr HandlerReq) {
   w, r, rpc, dir := hr.w, hr.r, hr.Rpc, hr.Dir
-  access := has_access(r, dir, rpc, true)
+  access := hasAccess(r, dir, rpc, true)
 
   if access == false {
-    render_no_access(w)
+    renderNoAccess(w)
     return
   }
 
@@ -133,62 +133,62 @@ func service_rpc(hr HandlerReq) {
   cmd.Wait()
 }
 
-func get_info_refs(hr HandlerReq) {
+func getInfoRefs(hr HandlerReq) {
   w, r, dir := hr.w, hr.r, hr.Dir
-  service_name := get_service_type(r)
-  access := has_access(r, dir, service_name, false)
+  service_name := getServiceType(r)
+  access := hasAccess(r, dir, service_name, false)
 
   if access {
     args := []string{service_name, "--stateless-rpc", "--advertise-refs", "."}
-    refs := git_command(dir, args...)
+    refs := gitCommand(dir, args...)
 
-    hdr_nocache(w)
+    hdrNocache(w)
     w.Header().Set("Content-Type", fmt.Sprintf("application/x-git-%s-advertisement", service_name))
     w.WriteHeader(http.StatusOK)
-    w.Write(packet_write("# service=git-" + service_name + "\n"))
-    w.Write(packet_flush())
+    w.Write(packetWrite("# service=git-" + service_name + "\n"))
+    w.Write(packetFlush())
     w.Write(refs)
   } else {
-    update_server_info(dir)
-    hdr_nocache(w)
-    send_file("text/plain; charset=utf-8", hr)
+    updateServerInfo(dir)
+    hdrNocache(w)
+    sendFile("text/plain; charset=utf-8", hr)
   }
 }
 
-func get_info_packs(hr HandlerReq) {
-  hdr_cache_forever(hr.w)
-  send_file("text/plain; charset=utf-8", hr)
+func getInfoPacks(hr HandlerReq) {
+  hdrCacheForever(hr.w)
+  sendFile("text/plain; charset=utf-8", hr)
 }
 
-func get_loose_object(hr HandlerReq) {
-  hdr_cache_forever(hr.w)
-  send_file("application/x-git-loose-object", hr)
+func getLooseObject(hr HandlerReq) {
+  hdrCacheForever(hr.w)
+  sendFile("application/x-git-loose-object", hr)
 }
 
-func get_pack_file(hr HandlerReq) {
-  hdr_cache_forever(hr.w)
-  send_file("application/x-git-packed-objects", hr)
+func getPackFile(hr HandlerReq) {
+  hdrCacheForever(hr.w)
+  sendFile("application/x-git-packed-objects", hr)
 }
 
-func get_idx_file(hr HandlerReq) {
-  hdr_cache_forever(hr.w)
-  send_file("application/x-git-packed-objects-toc", hr)
+func getIdxFile(hr HandlerReq) {
+  hdrCacheForever(hr.w)
+  sendFile("application/x-git-packed-objects-toc", hr)
 }
 
-func get_text_file(hr HandlerReq) {
-  hdr_nocache(hr.w)
-  send_file("text/plain", hr)
+func getTextFile(hr HandlerReq) {
+  hdrNocache(hr.w)
+  sendFile("text/plain", hr)
 }
 
 // Logic helping functions
 
-func send_file(content_type string, hr HandlerReq) {
+func sendFile(content_type string, hr HandlerReq) {
   w, r := hr.w, hr.r
   req_file := path.Join(hr.Dir, hr.File)
 
   f, err := os.Stat(req_file)
   if os.IsNotExist(err) {
-    render_not_found(w)
+    renderNotFound(w)
     return
   }
 
@@ -199,7 +199,7 @@ func send_file(content_type string, hr HandlerReq) {
 }
 
 
-func get_git_dir(file_path string) (string, error) {
+func getGitDir(file_path string) (string, error) {
   root := config.ProjectRoot
 
   if root == "" {
@@ -221,7 +221,7 @@ func get_git_dir(file_path string) (string, error) {
   return f, nil
 }
 
-func get_service_type(r *http.Request) string {
+func getServiceType(r *http.Request) string {
   service_type := r.FormValue("service")
 
   if s := strings.HasPrefix(service_type, "git-"); !s {
@@ -231,7 +231,7 @@ func get_service_type(r *http.Request) string {
   return strings.Replace(service_type, "git-", "", 1)
 }
 
-func has_access(r *http.Request, dir string, rpc string, check_content_type bool) bool {
+func hasAccess(r *http.Request, dir string, rpc string, check_content_type bool) bool {
   if check_content_type {
     if r.Header.Get("Content-Type") != fmt.Sprintf("application/x-git-%s-request", rpc) {
       return false
@@ -248,12 +248,12 @@ func has_access(r *http.Request, dir string, rpc string, check_content_type bool
     return config.UploadPack
   }
 
-  return get_config_setting(rpc, dir)
+  return getConfigSetting(rpc, dir)
 }
 
-func get_config_setting(service_name string, dir string) bool {
+func getConfigSetting(service_name string, dir string) bool {
   service_name = strings.Replace(service_name, "-", "", -1)
-  setting := get_git_config("http." + service_name, dir)
+  setting := getGitConfig("http." + service_name, dir)
 
   if service_name == "uploadpack" {
     return setting != "false"
@@ -262,18 +262,18 @@ func get_config_setting(service_name string, dir string) bool {
   return setting == "true"
 }
 
-func get_git_config(config_name string, dir string) string {
+func getGitConfig(config_name string, dir string) string {
   args := []string{"config", config_name}
-  out := string(git_command(dir, args...))
+  out := string(gitCommand(dir, args...))
   return out[0:len(out)-1]
 }
 
-func update_server_info(dir string) []byte {
+func updateServerInfo(dir string) []byte {
   args := []string{"update-server-info"}
-  return git_command(dir, args...)
+  return gitCommand(dir, args...)
 }
 
-func git_command(dir string, args ...string) []byte {
+func gitCommand(dir string, args ...string) []byte {
   command := exec.Command(config.GitBinPath, args...)
   command.Dir = dir
   out, err := command.Output()
@@ -287,7 +287,7 @@ func git_command(dir string, args ...string) []byte {
 
 // HTTP error response handling functions
 
-func render_method_not_allowed(w http.ResponseWriter, r *http.Request) {
+func renderMethodNotAllowed(w http.ResponseWriter, r *http.Request) {
   if r.Proto == "HTTP/1.1" {
     w.WriteHeader(http.StatusMethodNotAllowed)
     w.Write([]byte("Method Not Allowed"))
@@ -297,23 +297,23 @@ func render_method_not_allowed(w http.ResponseWriter, r *http.Request) {
   }
 }
 
-func render_not_found(w http.ResponseWriter) {
+func renderNotFound(w http.ResponseWriter) {
   w.WriteHeader(http.StatusNotFound)
   w.Write([]byte("Not Found"))
 }
 
-func render_no_access(w http.ResponseWriter) {
+func renderNoAccess(w http.ResponseWriter) {
   w.WriteHeader(http.StatusForbidden)
   w.Write([]byte("Forbidden"))
 }
 
 // Packet-line handling function
 
-func packet_flush() []byte {
+func packetFlush() []byte {
   return []byte("0000")
 }
 
-func packet_write(str string) []byte {
+func packetWrite(str string) []byte {
   s := strconv.FormatInt(int64(len(str) + 4), 16)
 
   if len(s) % 4 != 0 {
@@ -325,13 +325,13 @@ func packet_write(str string) []byte {
 
 // Header writing functions
 
-func hdr_nocache(w http.ResponseWriter) {
+func hdrNocache(w http.ResponseWriter) {
   w.Header().Set("Expires", "Fri, 01 Jan 1980 00:00:00 GMT")
   w.Header().Set("Pragma", "no-cache")
   w.Header().Set("Cache-Control", "no-cache, max-age=0, must-revalidate")
 }
 
-func hdr_cache_forever(w http.ResponseWriter) {
+func hdrCacheForever(w http.ResponseWriter) {
   now := time.Now().Unix()
   expires := now + 31536000
   w.Header().Set("Date", fmt.Sprintf("%d", now))
@@ -342,7 +342,7 @@ func hdr_cache_forever(w http.ResponseWriter) {
 // Main
 
 func main() {
-  http.HandleFunc("/", request_handler())
+  http.HandleFunc("/", requestHandler())
 
   err := http.ListenAndServe(":8080", nil)
   if err != nil {