Adding the ability to click on the images in the history and have that load

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/json"
         "flag"
         "fmt"
@@ skipping 49 matching lines @@
 
         // directLink is the regex that matches URLs paths that are direct links.
         directLink = regexp.MustCompile("^/c/([a-f0-9]+)$")
 
         // iframeLink is the regex that matches URLs paths that are links to iframes.
         iframeLink = regexp.MustCompile("^/iframe/([a-f0-9]+)$")
 
         // imageLink is the regex that matches URLs paths that are direct links to PNGs.
         imageLink = regexp.MustCompile("^/i/([a-f0-9]+.png)$")
 
+        // tryInfoLink is the regex that matches URLs paths that are direct links to data about a single try.
+        tryInfoLink = regexp.MustCompile("^/json/([a-f0-9]+)$")
+
         // workspaceLink is the regex that matches URLs paths for workspaces.
         workspaceLink = regexp.MustCompile("^/w/([a-z0-9-]+)$")
 
         // workspaceNameAdj is a list of adjectives for building workspace names.
         workspaceNameAdj = []string{
                 "autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
                 "summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
                 "patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
                 "billowing", "broken", "cold", "damp", "falling", "frosty", "green",
                 "long", "late", "lingering", "bold", "little", "morning", "muddy", "old",
@@ skipping 295 matching lines @@
                 recent = append(recent, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
         }
         if err := recentTemplate.Execute(w, Recent{Tries: recent}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
 type Workspace struct {
         Name  string
         Code  string
+        Hash  string
         Tries []Try
 }
 
 // newWorkspace generates a new random workspace name and stores it in the database.
 func newWorkspace() (string, error) {
         for i := 0; i < 10; i++ {
                 adj := workspaceNameAdj[rand.Intn(len(workspaceNameAdj))]
                 noun := workspaceNameNoun[rand.Intn(len(workspaceNameNoun))]
                 suffix := rand.Intn(1000)
                 name := fmt.Sprintf("%s-%s-%d", adj, noun, suffix)
                 if _, err := db.Exec("INSERT INTO workspace (name) VALUES(?)", name); err == nil {
                         return name, nil
                 } else {
                         log.Printf("ERROR: Failed to insert workspace into database: %q\n", err)
                 }
         }
         return "", fmt.Errorf("Failed to create a new workspace")
 }
 
 // getCode returns the code for a given hash, or the empty string if not found.
-func getCode(hash string) string {
+func getCode(hash string) (string, error) {
         code := ""
         if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
                 log.Printf("ERROR: Code for hash is missing: %q\n", err)
+                return code, err
         }
-        return code
+        return code, nil
 }
 
 func workspaceHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Workspace Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
                         rows, err := db.Query("SELECT create_ts, hash FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
                                 if err := rows.Scan(&create_ts, &hash); err != nil {
                                         log.Printf("Error: failed to fetch from database: %q", err)
                                         continue
                                 }
                                 tries = append(tries, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
                         }
                 }
                 var code string
+                var hash string
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                 } else {
-                        code = getCode(tries[len(tries)-1].Hash)
+                        hash = tries[len(tries)-1].Hash
+                        code, _ = getCode(hash)

[mtklein, 2014/04/22 17:24:18]

Might as well handle this error?  Even if this is logically impossible, it still
could happen due to network error or something like that right?

[jcgregorio, 2014/04/22 18:02:08]

In case of error getCode returns the empty string, which is what I want. Also,
getCode will log any errors it encounters, so I don't need to do that here.

On 2014/04/22 17:24:18, mtklein wrote:

                 }
-                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name}); err != nil {
+                if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 name, err := newWorkspace()
                 if err != nil {
                         http.Error(w, "Failed to create a new workspace.", 500)
                         return
                 }
                 http.Redirect(w, r, "/w/"+name, 302)
         }
 }
 
 // hasPreProcessor returns true if any line in the code begins with a # char.
 func hasPreProcessor(code string) bool {
         lines := strings.Split(code, "\n")
         for _, s := range lines {
                 if strings.HasPrefix(strings.TrimSpace(s), "#") {
                         return true
                 }
         }
         return false
 }
 
 type TryRequest struct {
         Code string `json:"code"`
-        Name string `json:"name"`
+        Name string `json:"name"` // Optional name of the workspace the code is in.
 }
 
 // iframeHandler handles the GET and POST of the main page.
 func iframeHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("IFrame Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := iframeLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
         if db == nil {
                 http.NotFound(w, r)
                 return
         }
         var code string
-        // Load 'code' with the code found in the database.
-        if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
+        code, err := getCode(hash)
+        if err != nil {
                 http.NotFound(w, r)
                 return
         }
         // Expand the template.
         if err := iframeTemplate.Execute(w, userCode{UserCode: code, Hash: hash}); err != nil {
                 log.Printf("ERROR: Failed to expand template: %q\n", err)
         }
 }
 
+type TryInfo struct {
+        Hash string `json:"hash"`
+        Code string `json:"code"`
+}
+
+// tryInfoHandler returns information about a specific try.
+func tryInfoHandler(w http.ResponseWriter, r *http.Request) {
+        log.Printf("Try Info Handler: %q\n", r.URL.Path)
+        if r.Method != "GET" {
+                http.NotFound(w, r)
+                return
+        }
+        match := tryInfoLink.FindStringSubmatch(r.URL.Path)
+        if len(match) != 2 {
+                http.NotFound(w, r)
+                return
+        }
+        hash := match[1]
+        code, err := getCode(hash)
+        if err != nil {
+                http.NotFound(w, r)
+                return
+        }
+        m := TryInfo{
+                Hash: hash,
+                Code: code,
+        }
+        resp, err := json.Marshal(m)
+        if err != nil {
+                reportError(w, r, err, "Failed to serialize a response.")
+                return
+        }
+        w.Header().Set("Content-Type", "application/json")
+        w.Write(resp)
+}
+
 // mainHandler handles the GET and POST of the main page.
 func mainHandler(w http.ResponseWriter, r *http.Request) {
         log.Printf("Main Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
                 match := directLink.FindStringSubmatch(r.URL.Path)
+                var hash string
                 if len(match) == 2 && r.URL.Path != "/" {
-                        hash := match[1]
+                        hash = match[1]
                         if db == nil {
                                 http.NotFound(w, r)
                                 return
                         }
                         // Update 'code' with the code found in the database.
                         if err := db.QueryRow("SELECT code FROM webtry WHERE hash=?", hash).Scan(&code); err != nil {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
-                if err := indexTemplate.Execute(w, userCode{UserCode: code}); err != nil {
+                if err := indexTemplate.Execute(w, userCode{UserCode: code, Hash: hash}); err != nil {
                         log.Printf("ERROR: Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 w.Header().Set("Content-Type", "application/json")
                 buf := bytes.NewBuffer(make([]byte, 0, MAX_TRY_SIZE))
                 n, err := buf.ReadFrom(r.Body)
                 if err != nil {
                         reportError(w, r, err, "Failed to read a request body.")
                         return
                 }
@@ skipping 65 matching lines @@
                 w.Write(resp)
         }
 }
 
 func main() {
         flag.Parse()
         http.HandleFunc("/i/", imageHandler)
         http.HandleFunc("/w/", workspaceHandler)
         http.HandleFunc("/recent/", recentHandler)
         http.HandleFunc("/iframe/", iframeHandler)
+        http.HandleFunc("/json/", tryInfoHandler)
         http.HandleFunc("/css/", cssHandler)
         http.HandleFunc("/js/", jsHandler)
+        // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", mainHandler)
         log.Fatal(http.ListenAndServe(*port, nil))
 }