about summary refs log blame commit diff stats
path: root/shell/data.limg
blob: 534ecd5122a18445d021c6cf64d7b23d126651ae (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14













                                                          








                                                                          

                                                                    
































                                                                     
                                   


                                                        

                                                         



                                                                     
                                          




















                                                                      

                                      
    
                                        
 
(
  (globals . (
    (hline1 . (fn () (screen y lo hi color)
                (while (< lo hi)
                  (pixel screen lo y color)
                  (set lo (+ lo 1)))))
    (vline1 . (fn () (screen x lo hi color)
                (while (< lo hi)
                  (pixel screen x lo color)
                  (set lo (+ lo 1)))))
    (hline . (fn () (screen y color)
               (hline1 screen y 0 (width screen) color)))
    (vline . (fn () (screen y color)
               (vline1 screen y 0 (height screen) color)))
    (brline . (fn () (screen x0 y0 x1 y1 color)
                 ((fn (dx dy sx sy)
                    ((fn (err)
                       (brline1 screen x0 y0 x1 y1 dx dy sx sy err color))
                     (+ dx dy)))
                  (abs (- x1 x0))
                  (- 0 (abs (- y1 y0)))
                  (sgn (- x1 x0))
                  (sgn (- y1 y0)))))
    (brline1 . (fn () (screen x y xlast ylast dx dy sx sy err color)
                 (while (not (and (= x xlast) (= y ylast)))
                   (pixel screen x y color)
                   ((fn (e2)
                      (if (>= e2 dy)
                        (set x (+ x sx))
                        ())
                      (if (<= e2 dx)
                        (set y (+ y sy)))
                      (set err (+ err
                           (+
                             (if (>= e2 dy)
                               dy
                               0)
                             (if (<= e2 dx)
                               dx
                               0)))))
                    (* err 2)))))
    (read_line_2 . (fn () (keyboard stream)
                     ((fn (c)
                       (if (= c 10)
                         stream
                         (if (= c 0)
                           stream
                           (read_line_2 keyboard (write stream c)))))
                      (key keyboard))))
    (read_line . (fn () (keyboard)
                   (read_line_2 keyboard (stream))))
    (fill_rect . (fn () (screen x1 y1 x2 y2 fill_color)
                   (while (< y1 y2)
                     (hline1 screen y1 x1 x2 fill_color)
                     (set y1 (+ y1 1)))))
    (chessboard . (fn () (screen px)
                    (chessboard1 screen px 0 15)))
    (chessboard1 . (fn () (screen px y color)
                     (clear screen)
                     (while (< y (height screen))
                       (chessboard2 screen px y 0 color)
                       (set y (+ y px))
                       (chessboard2 screen px y px color)
                       (set y (+ y px)))))
    (chessboard2 . (fn () (screen px y x color)
                     (while (< x (width screen))
                       (fill_rect screen x y (+ x px) (+ y px) color)
                       (set x (+ x px))
                       (set x (+ x px)))))
    (brcircle . (fn () (screen cx cy r color)
                  ((fn (x y err continue)
                     (while continue
                       (pixel screen (- cx x) (+ cy y) color)
                       (pixel screen (- cx y) (- cy x) color)
                       (pixel screen (+ cx x) (- cy y) color)
                       (pixel screen (+ cx y) (+ cy x) color)
                       (set r err)
                       (if (<= r y)
                         (set err (+ err (+ 1 (* 2 (set y (+ y 1))))))
                         ())
                       (if (or (> r x) (> err y))
                         (set err (+ err (+ 1 (* 2 (set x (+ x 1))))))
                         ())
                       (set continue (< x 0))
                       ))
                    (- 0 r)
                    0
                    (- 2 (* 2 r))
                    1
                   )))
    (main . (fn () (screen keyboard)
              (chessboard screen 16)))
  ))
  (sandbox . (brcircle screen 5 5 3 12))
)
> 2019-05-14 20:53:40 -0400 allowing underscore and hyphen in users/tags' href='/gbmor/getwtxt/commit/main.go?h=v0.2.1&id=dfab6f205088e50bab66485359e9d9c85777a221'>dfab6f2 ^
d2680fb ^

fb63b07 ^
cd635e6 ^


711012e ^
bd5e602 ^

c87acad ^
747f4fb ^
06cffd8 ^
c87acad ^


893123c ^
bd23ef0 ^
c87acad ^

3596509 ^
c87acad ^
bd5e602 ^
d083ce6 ^
893123c ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104


            
             

                  
              

                                     
                                


             
                     
 


                                                        
                                                  

                                                   


                                         
 


                                       
 


                                           
 

                                                          


                                             
 

                                                                      
                                                                             
                               
                                               
 
                                                                             
                                                  
                                                                             
                                                        
                               
                                               
 

                                                                            
                                                         
                                                                                 
                                
                                                   
 













                                                                 
                                 


                                               
 
                                                
                                                                   

                                           
 


                                                   
 

                                                        
                               
                                                                            
                                      


                                               
 
                                                

                                      
                                               
         
 
                        
 
package main

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/handlers"
	"github.com/gorilla/mux"
)

func main() {
	initGetwtxt()

	// StrictSlash(true) allows /api and /api/
	// to serve the same content without duplicating
	// handlers/paths
	index := mux.NewRouter().StrictSlash(true)
	api := index.PathPrefix("/api").Subrouter()

	index.Path("/").
		Methods("GET").
		HandlerFunc(indexHandler)

	index.Path("/css").
		Methods("GET").
		HandlerFunc(cssHandler)

	index.Path("/api").
		Methods("GET").
		HandlerFunc(apiBaseHandler)

	// twtxt will add support for other formats later.
	// Maybe json? Making this future-proof.
	api.Path("/{format:(?:plain)}").
		Methods("GET").
		HandlerFunc(apiFormatHandler)

	// Specifying the endpoint with and without query information.
	// Will return 404 on empty queries otherwise.
	api.Path("/{format:(?:plain)}/{endpoint:(?:mentions|users|tweets)}").
		Methods("GET").
		HandlerFunc(apiEndpointHandler)

	// Using stdlib net/url to validate the input URLs rather than regex.
	// Validating a URL with regex is unwieldy
	api.Path("/{format:(?:plain)}/{endpoint:(?:mentions|users|tweets)}").
		Queries("url", "{url}", "q", "{query}").
		Methods("GET").
		HandlerFunc(apiEndpointHandler)

	// This is for submitting new users. Both query variables must exist
	// in the request for this to match.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("url", "{url}", "nickname", "{nickname:[a-zA-Z0-9_-]+}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// This is for submitting new users incorrectly
	// and letting the requester know about their error.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("url", "{url}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// This is for submitting new users incorrectly
	// and letting the requester know about their error.
	api.Path("/{format:(?:plain)}/{endpoint:users}").
		Queries("nickname", "{nickname:[a-zA-Z0-9_-]+}").
		Methods("POST").
		HandlerFunc(apiEndpointPOSTHandler)

	// Show all observed tags
	api.Path("/{format:(?:plain)}/tags").
		Methods("GET").
		HandlerFunc(apiTagsBaseHandler)

	// Requests statuses with a specific tag
	api.Path("/{format:(?:plain)}/tags/{tags:[a-zA-Z0-9_-]+}").
		Methods("GET").
		HandlerFunc(apiTagsHandler)

	confObj.Mu.RLock()
	portnum := fmt.Sprintf(":%v", confObj.Port)
	confObj.Mu.RUnlock()

	// handlers.CompressHandler gzips all responses.
	// Write/Read timeouts are self explanatory.
	server := &http.Server{
		Handler:      handlers.CompressHandler(ipMiddleware(index)),
		Addr:         portnum,
		WriteTimeout: 15 * time.Second,
		ReadTimeout:  15 * time.Second,
	}

	log.Printf("Listening on %v\n", portnum)
	err := server.ListenAndServe()
	if err != nil {
		log.Printf("%v\n", err.Error())
	}

	closeLog <- true
}