func GetNpcs() (npcs []*Npc) {
var data []NpcInfo
err := utils.LoadSetting(&data, "data/npc.json")
if err != nil {
panic(err.Error())
}
for _, npcType := range data {
for _, location := range npcType.Locations {
for locName, count := range location {
counter := 0
npcClass := npcType.Class
npcBehavior := npcType.Behavior
for i := 0; i < count; i++ {
counter++
npc := &Npc{
Character{
Name: fmt.Sprintf("%s#%d", strings.ToTitle(npcBehavior), counter),
Class: npcClass,
CurrentLocation: locName,
OwnerUid: fmt.Sprintf("%s#%d", strings.ToTitle(npcBehavior), counter),
},
ai.Behavior(npcBehavior),
}
npc.SetDefaults()
npcs = append(npcs, npc)
}
}
}
}
return
}
func ExampleToTitle() {
fmt.Println(strings.ToTitle("loud noises"))
fmt.Println(strings.ToTitle("хлеб"))
// Output:
// LOUD NOISES
// ХЛЕБ
}
func main() {
fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
fmt.Println(strings.ContainsAny("team", "e"))
fmt.Println(strings.ContainsAny("failure", "u & i"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))
fmt.Println(1 & 1)
fmt.Println(2 & 1)
fmt.Println(4 & 1)
fmt.Println(5 & 1)
pow, sq := HashTest("1234567")
fmt.Println(pow)
fmt.Println(sq)
str := "df 世 界 asd"
s := "1界"
index := strings.IndexAny(str, "界")
fmt.Printf("%d......\n", index)
for i, c := range str {
fmt.Println(i)
for _, m := range s {
fmt.Printf("%c\t%c\n", c, m)
}
}
for i := len(str); i > 0; {
rune, size := utf8.DecodeLastRuneInString(str[0:i])
fmt.Printf("%v\t", i)
i -= size
for _, m := range s {
fmt.Printf("%c\t%v\t%v\n", rune, size, m)
}
}
fmt.Println("bytes =", len(str))
fmt.Println("runes =", utf8.RuneCountInString(str))
for _, ss := range strings.Fields(str) {
fmt.Println(ss)
}
fmt.Println(strings.ToTitle(str))
str = "Hello, 世界"
// for len(str) > 0 {
// r, size := utf8.DecodeRuneInString(str)
// fmt.Printf("%c %v\n", r, size)
// str = str[size:]
// }
fmt.Println(Replace(str, "", "f", -1))
hulu := new(huluwa)
hello(hulu)
}
// Renders a set of data provided by the module into the format specified by the request. Normally, this means that the data is rendered into HTML (mobile vs. desktop is automatically selected), but we may add support for ?alt=json or such at a later point
func Render(c http.ResponseWriter, r *http.Request, title, name string, data interface{}) {
if WouldUseJson(r) {
enc := json.NewEncoder(c)
err := enc.Encode(data)
if err != nil {
Error500(c, r, err)
}
return
}
var p PageInfo
if title == "" {
title = strings.ToTitle(moduleName)
}
// if moduleName == "unknown" {
// log.Println("Warning: Attempting to render a template without moduleName being set! Call SetModuleName during the initialization of your module in order to correct this (in main()).")
// }
p.Title = title
// Removed the modulename because it's not needed in the new framework. However, this will break things in the old framework. *sigh*...
p.Name = /*moduleName + "/" + */ name
p.Request = r
perms, err := perms.Get(r)
if err != nil {
log.Printf("Warning: Error getting page permissions for %s: %s", r.URL, err)
}
p.Perms = perms
p.Object = data
err = Execute(c, &p)
if err != nil {
c.WriteHeader(500)
fmt.Fprintln(c, "FATAL ERROR:", err)
return
}
}
func (m *HttpTampererSymptom) MuckRequest(ctx *muxy.Context) {
// Body
if m.Request.Body != "" {
newreq, err := http.NewRequest(ctx.Request.Method, ctx.Request.URL.String(), bytes.NewBuffer([]byte(m.Request.Body)))
if err != nil {
log.Error(err.Error())
}
*ctx.Request = *newreq
log.Debug("Spoofing HTTP Request Body with %s", log.Colorize(log.BLUE, m.Request.Body))
}
// Set Cookies
for _, c := range m.Request.Cookies {
c.Expires = stringToDate(c.RawExpires)
log.Debug("Spoofing Request Cookie %s => %s", log.Colorize(log.LIGHTMAGENTA, c.Name), c.String())
ctx.Request.Header.Add("Cookie", c.String())
}
// Set Headers
for k, v := range m.Request.Headers {
key := strings.ToTitle(strings.Replace(k, "_", "-", -1))
log.Debug("Spoofing Request Header %s => %s", log.Colorize(log.LIGHTMAGENTA, key), v)
ctx.Request.Header.Set(key, v)
}
// This Writes all headers, setting status code - so call this last
if m.Request.Method != "" {
ctx.Request.Method = m.Request.Method
}
}
func titleCaseFirstLetter(in string) string {
out := ""
out += string(in[0])
out = strings.ToTitle(out)
out += in[1:]
return out
}
func convertStruct(in interface{}, val reflect.Value) *ConfigError {
dict, ok := in.(map[string]interface{})
if !ok || len(dict) != val.NumField() {
return &ConfigError{ErrInvalidType, ""}
}
for k, from := range dict {
to := val.FieldByName(strings.ToTitle(k[:1]) + k[1:])
if !to.IsValid() {
return &ConfigError{ErrInvalidType, ""}
}
convertor := convertFuncs.get(to)
if convertor == nil {
return &ConfigError{ErrInvalidType, ""}
}
if err := convertor(from, to); err != nil {
if len(err.Field) > 0 {
err.Field = fmt.Sprintf("%s.%s", k, err.Field)
} else {
err.Field = k
}
return err
}
}
return nil
}
func doLogGPUStatus() {
var stdout, stderr bytes.Buffer
logGPU := func(toLog string) {
cmd := exec.Command("nvidia-smi ",
"-q", "-d", toLog, "|", "grep", "Gpu", "|", "cut", "-c35-36")
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := RunCommandWithTimeout(5*time.Second, cmd)
if err != nil {
switch err.(type) {
case TimeoutError:
Incr(ServerRole+"-System", "GPUUnResponsive")
return
}
} else {
Log("System", strings.ToTitle(toLog),
string(stdout.Bytes())+"::"+string(stderr.Bytes()))
}
}
logGPU("MEMORY")
logGPU("UTILIZATION")
logGPU("PERFORMANCE")
logGPU("ECC")
logGPU("CLOCK")
logGPU("TEMPERATURE")
}
func addPlist(name string, config *Dashing) {
var file bytes.Buffer
t := template.Must(template.New("plist").Parse(plist))
fancyName := config.Name
if len(fancyName) == 0 {
fancyName = strings.ToTitle(name)
}
aj := "false"
if config.AllowJS {
aj = "true"
}
tvars := map[string]string{
"Name": name,
"FancyName": fancyName,
"Index": config.Index,
"AllowJS": aj,
"ExternalURL": config.ExternalURL,
}
err := t.Execute(&file, tvars)
if err != nil {
fmt.Printf("Failed: %s\n", err)
return
}
ioutil.WriteFile(name+".docset/Contents/Info.plist", file.Bytes(), 0755)
}
func (tester *TestSearchSpaces) createTestData() ([]space.Space, error) {
names := []string{"TEST_A", "TEST_AB", "TEST_B", "TEST_C"}
for i := 0; i < 20; i++ {
names = append(names, "TEST_"+strconv.Itoa(i))
}
spaces := []space.Space{}
err := application.Transactional(tester.db, func(app application.Application) error {
for _, name := range names {
space := space.Space{
Name: name,
Description: strings.ToTitle("description for " + name),
}
newSpace, err := app.Spaces().Create(context.Background(), &space)
if err != nil {
return err
}
spaces = append(spaces, *newSpace)
}
return nil
})
if err != nil {
return nil, fmt.Errorf("Failed to insert testdata", err)
}
return spaces, nil
}
// TitleCase replace _ with space and upcase every word
func TitleCase(s string) string {
ss := strings.Fields(strings.Replace(s, "_", " ", -1))
for i := range ss {
ss[i] = strings.ToTitle(ss[i][:1]) + ss[i][1:]
}
return strings.Join(ss, " ")
}
func Forgot(w http.ResponseWriter, r *http.Request) {
var err error
var tmpl *plate.Template
params := r.URL.Query()
error := params.Get("error")
error, _ = url.QueryUnescape(error)
server := plate.NewServer()
tmpl, err = server.Template(w)
if err != nil {
plate.Serve404(w, err.Error())
return
}
tmpl.Bag["PageTitle"] = "Forgot Password"
tmpl.Bag["Error"] = strings.ToTitle(error)
tmpl.Bag["CurrentYear"] = time.Now().Year()
tmpl.Bag["userID"] = 0
tmpl.FuncMap["isNotNull"] = func(str string) bool {
if strings.TrimSpace(str) != "" && len(strings.TrimSpace(str)) > 0 {
return true
}
return false
}
tmpl.FuncMap["isLoggedIn"] = func() bool {
return false
}
templates := append(TemplateFiles, "templates/auth/forgot.html")
tmpl.DisplayMultiple(templates)
}
func SignUp(w http.ResponseWriter, r *http.Request) {
var err error
var tmpl *plate.Template
params := r.URL.Query()
error := params.Get("error")
error, _ = url.QueryUnescape(error)
fname := params.Get("fname")
fname, _ = url.QueryUnescape(fname)
lname := params.Get("lname")
lname, _ = url.QueryUnescape(lname)
email := params.Get("email")
email, _ = url.QueryUnescape(email)
username := params.Get("username")
username, _ = url.QueryUnescape(username)
var submitted bool
submitted, err = strconv.ParseBool(params.Get("submitted"))
if err != nil {
submitted = false
}
server := plate.NewServer()
tmpl, err = server.Template(w)
if err != nil {
plate.Serve404(w, err.Error())
return
}
tmpl.Bag["PageTitle"] = "Register"
tmpl.Bag["Error"] = strings.ToTitle(error)
tmpl.Bag["Fname"] = strings.TrimSpace(fname)
tmpl.Bag["Lname"] = strings.TrimSpace(lname)
tmpl.Bag["Email"] = strings.TrimSpace(email)
tmpl.Bag["Username"] = strings.TrimSpace(username)
tmpl.Bag["CurrentYear"] = time.Now().Year()
tmpl.Bag["Submitted"] = submitted
tmpl.Bag["userID"] = 0
tmpl.FuncMap["isNotNull"] = func(str string) bool {
if strings.TrimSpace(str) != "" && len(strings.TrimSpace(str)) > 0 {
return true
}
return false
}
tmpl.FuncMap["isLoggedIn"] = func() bool {
return false
}
templates := append(TemplateFiles, "templates/auth/signup.html")
tmpl.DisplayMultiple(templates)
}
func TestPaperKeyPhraseTypos(t *testing.T) {
p, err := MakePaperKeyPhrase(0)
if err != nil {
t.Fatal(err)
}
equivs := []string{
p.String(),
" " + p.String(),
p.String() + " ",
" " + p.String() + " ",
"\t" + p.String() + " ",
" " + p.String() + "\t",
strings.Join(strings.Split(p.String(), " "), " "),
strings.ToTitle(p.String()),
strings.ToUpper(p.String()),
}
for _, s := range equivs {
q := NewPaperKeyPhrase(s)
version, err := q.Version()
if err != nil {
t.Fatal(err)
}
if version != 0 {
t.Errorf("input: %q => version: %d, expected 0", s, version)
}
if q.String() != p.String() {
t.Errorf("input: %q => phrase %q, expected %q", s, q.String(), p.String())
}
if len(q.InvalidWords()) > 0 {
t.Errorf("input: %q => phrase %q, contains invalid words %v", s, q.String(), q.InvalidWords())
}
}
// make a typo in one of the words
w := strings.Fields(p.String())
w[0] = w[0] + "qx"
x := strings.Join(w, " ")
q := NewPaperKeyPhrase(x)
// version should still be ok
version, err := q.Version()
if err != nil {
t.Fatal(err)
}
if version != 0 {
t.Errorf("input: %q => version: %d, expected 0", x, version)
}
// but InvalidWords should return the first word as invalid
if len(q.InvalidWords()) == 0 {
t.Fatalf("input: %q => all words valid, expected %s to be invalid", x, w[0])
}
if q.InvalidWords()[0] != w[0] {
t.Errorf("input: %q => invalid words %v, expected %s", x, q.InvalidWords(), w[0])
}
}
func main() {
fmt.Println("Hello World")
fmt.Println(strings.ToTitle("Hello World"))
fmt.Println(strings.ToLower("hello world"))
fmt.Println(strings.Replace("Hello World Hello World Hello World", "Hello", "Come", 2))
fmt.Println(strings.Replace(" Aero space", " ", "", 2)) // Remove space
fmt.Println(strings.TrimSpace(" Aero space")) // Also remove space but in the front
}
func NewBlogTuple(path, targetExt string) (BlogTuple, bool) {
path = filepath.Base(path)
m := BlogEntryRegexp.FindAllStringSubmatch(path, -1)
if len(m) <= 0 {
Debugf("Blog Tuple: %s: failed to parse stage 0", path)
return BlogTuple{}, false
}
if len(m[0]) < 5 {
Debugf("Blog Tuple: %s: failed to parse stage 1", path)
return BlogTuple{}, false
}
if len(m[0][1]) <= 0 || len(m[0][2]) <= 0 || len(m[0][3]) <= 0 {
Debugf("Blog Tuple: %s: failed to parse stage 2", path)
return BlogTuple{}, false
}
yyyy, err := strconv.ParseInt(m[0][1], 10, 32)
if err != nil {
Debugf("Blog Tuple: %s: bad year '%s'", path, m[1])
return BlogTuple{}, false
}
mm, err := strconv.ParseInt(m[0][2], 10, 32)
if err != nil {
Debugf("Blog Tuple: %s: bad month '%s'", path, m[2])
return BlogTuple{}, false
}
dd, err := strconv.ParseInt(m[0][3], 10, 32)
if err != nil {
Debugf("Blog Tuple: %s: bad day '%s'", path, m[3])
return BlogTuple{}, false
}
if len(m[0][4]) <= 0 {
Debugf("Blog Tuple: %s: failed to parse stage 3", path)
return BlogTuple{}, false
}
filename := m[0][4]
title := filename
title = strings.Replace(title, "-", " ", -1)
title = strings.Replace(title, "_", " ", -1)
title = strings.ToTitle(string(title[0])) + title[1:]
Debugf("Blog Tuple: %s: OK", path)
return BlogTuple{
Year: int(yyyy),
Month: int(mm),
Day: int(dd),
Title: title,
Filename: filename + targetExt,
}, true
}
func stringFunktionenXmpl() {
fmt.Println(strings.ToLower(satz1))
fmt.Println(strings.ToTitle(satz1))
fmt.Println(strings.Title(satz1))
fmt.Println(strings.Count(satz1, "braun"))
fmt.Println(strings.Fields(satz1)[0])
fmt.Println(strings.Repeat("Fuchs ", 4))
fmt.Println(strings.Replace(satz1, "braun", "rot", -1))
}
func camel2const(s string) string {
b := bytes.Buffer{}
var c rune
start := 0
end := 0
for end, c = range s {
if c >= 'A' && c <= 'Z' {
//uppercase all prior letters and add an underscore
if start < end {
b.WriteString(strings.ToTitle(s[start:end] + "_"))
start = end
}
}
}
//write remaining string
b.WriteString(strings.ToTitle(s[start : end+1]))
return b.String()
}
func main() {
s := "heLLo worLd Ａｂｃ"
us := strings.ToUpper(s)
ls := strings.ToLower(s)
ts := strings.ToTitle(s)
fmt.Printf("%q\n", us) // "HELLO WORLD ＡＢＣ"
fmt.Printf("%q\n", ls) // "hello world ａｂｃ"
fmt.Printf("%q\n", ts) // "HELLO WORLD ＡＢＣ"
}
func fuz6(fcfg *fuzzCfg, data []byte, seed uint) {
raw := string(data)
x := ""
for _, r := range raw {
if r != utf8.RuneError {
x += string(r)
}
}
fcfg.cmp = []string{x, strings.ToTitle(x)}
}
func show(s string) {
fmt.Println("\nstring: ", s, "len:", utf8.RuneCountInString(s))
fmt.Println("All upper case: ", strings.ToUpper(s)) // DZLJNJ
fmt.Println("All lower case: ", strings.ToLower(s)) // dzljnj
fmt.Println("All title case: ", strings.ToTitle(s)) // DzLjNj
// notice Title() only modifies first letters of words
// non-first letters keep their case.
fmt.Println("Title words: ", strings.Title(s)) // Dzljnj
fmt.Println("Swapping case: ", strings.Map(unicode.SimpleFold, s))
}
func (m *SqlSource) String() string {
if int(m.Op) == 0 && int(m.LeftOrRight) == 0 && int(m.JoinType) == 0 {
if m.Alias != "" {
return fmt.Sprintf("%s AS %v", m.Name, m.Alias)
}
return m.Name
}
buf := bytes.Buffer{}
//u.Warnf("op:%d leftright:%d jointype:%d", m.Op, m.LeftRight, m.JoinType)
//u.Warnf("op:%s leftright:%s jointype:%s", m.Op, m.LeftRight, m.JoinType)
//u.Infof("%#v", m)
// Jointype Op
// INNER JOIN orders AS o ON
if int(m.JoinType) != 0 {
buf.WriteString(strings.ToTitle(m.JoinType.String()))
buf.WriteByte(' ')
}
buf.WriteString("JOIN ")
if m.Alias != "" {
buf.WriteString(fmt.Sprintf("%s AS %v", m.Name, m.Alias))
} else {
buf.WriteString(m.Name)
}
buf.WriteByte(' ')
buf.WriteString(strings.ToTitle(m.Op.String()))
//u.Warnf("JoinExpr? %#v", m.JoinExpr)
if m.JoinExpr != nil {
buf.WriteByte(' ')
buf.WriteString(m.JoinExpr.String())
//buf.WriteByte(' ')
}
//u.Warnf("source? %#v", m.Source)
// if m.Source != nil {
// buf.WriteString(m.Source.String())
// }
return buf.String()
}
func Fuzz(data []byte) int {
s := string(data)
si := len(s) / 4 * 3
s0 := s[:si]
s1 := s[si:]
s2, r := splitRune(s)
s3 := s[:len(s)/2]
s4 := s[len(s)/2:]
s5 := s[:len(s)/3]
s6 := s[len(s)/3 : len(s)/3*2]
s7 := s[len(s)/3*2:]
strings.Contains(s0, s1)
strings.ContainsAny(s0, s1)
strings.ContainsRune(s, r)
strings.Count(s0, s1)
strings.EqualFold(s3, s4)
fields := strings.Fields(s)
strings.HasPrefix(s0, s1)
strings.HasSuffix(s0, s1)
strings.Index(s0, s1)
strings.IndexAny(s0, s1)
strings.IndexByte(s2, byte(r))
strings.IndexRune(s2, r)
strings.Join(fields, " ")
strings.LastIndex(s0, s1)
strings.LastIndexAny(s0, s1)
strings.Repeat(s, 2)
strings.Replace(s, s0, s1, -1)
strings.Split(s0, s1)
strings.SplitAfter(s0, s1)
strings.SplitAfterN(s0, s1, 2)
strings.SplitN(s0, s1, 2)
strings.Title(s)
strings.ToLower(s)
strings.ToLowerSpecial(unicode.AzeriCase, s)
strings.ToTitle(s)
strings.ToTitleSpecial(unicode.AzeriCase, s)
strings.ToUpper(s)
strings.ToUpperSpecial(unicode.AzeriCase, s)
strings.Trim(s0, s1)
strings.TrimLeft(s0, s1)
strings.TrimPrefix(s0, s1)
strings.TrimRight(s0, s1)
strings.TrimSpace(s)
strings.TrimSuffix(s0, s1)
strings.NewReplacer(s5, s6).Replace(s7)
return 0
}
func EchoServer(ws *websocket.Conn) {
r := bufio.NewReader(ws)
for {
line, err := r.ReadString('\n')
if err != nil {
log.Println("ERR: ", err)
return
}
log.Println("READ:", line)
out := ">>>> " + strings.ToTitle(line)
ws.Write([]byte(out))
}
}
// Helper function to parse a blog posts filename, which is in the following
// format: YYYY-MM-DD-name-of-post.markdown
//
// the name of the post will be separated from the time of the post, both of
// which are returned by this function
func parsePostName(fn string) (name string, date time.Time, err error) {
if len(fn) < 12 {
err = ErrBadPostName
return
}
date, err = time.Parse("2006-01-02", fn[:10])
if err != nil {
return
}
name = fn[11:]
name = removeExt(name)
name = strings.Replace(name, "-", " ", -1)
name = strings.ToTitle(name)
return
}
func (m *HttpTampererSymptom) MuckResponse(ctx *muxy.Context) {
// Body
if m.Response.Body != "" {
var cl io.ReadCloser
cl = &responseBody{body: []byte(m.Response.Body)}
r := &http.Response{
Request: ctx.Request,
Header: ctx.Response.Header,
Close: ctx.Response.Close,
ContentLength: ctx.Response.ContentLength,
Trailer: ctx.Response.Trailer,
TLS: ctx.Response.TLS,
TransferEncoding: ctx.Response.TransferEncoding,
Status: ctx.Response.Status,
StatusCode: ctx.Response.StatusCode,
Proto: ctx.Response.Proto,
ProtoMajor: ctx.Response.ProtoMajor,
ProtoMinor: ctx.Response.ProtoMinor,
Body: cl,
}
log.Debug("Injecting HTTP Response Body with %s", log.Colorize(log.BLUE, m.Response.Body))
*ctx.Response = *r
}
// Set Cookies
for _, c := range m.Response.Cookies {
c.Expires = stringToDate(c.RawExpires)
log.Debug("Spoofing Response Cookie %s => %s", log.Colorize(log.LIGHTMAGENTA, c.Name), c.String())
ctx.Response.Header.Add("Set-Cookie", c.String())
}
// Set Headers
for k, v := range m.Response.Headers {
key := strings.ToTitle(strings.Replace(k, "_", "-", -1))
log.Debug("Spoofing Response Header %s => %s", log.Colorize(log.LIGHTMAGENTA, key), v)
ctx.Response.Header.Add(key, v)
}
// This Writes all headers, setting status code - so call this last
if m.Response.Status != 0 {
ctx.Response.StatusCode = m.Response.Status
ctx.Response.Status = http.StatusText(m.Response.Status)
}
}
func (m *HttpTampererSymptom) HandleEvent(e muxy.ProxyEvent, ctx *muxy.Context) {
switch e {
case muxy.EVENT_POST_DISPATCH:
log.Debug("Spoofing status code, responding with %s", log.Colorize(log.YELLOW, fmt.Sprintf("%d %s", m.Status, http.StatusText(m.Status))))
// Body
if m.Body != "" {
var cl io.ReadCloser
cl = &responseBody{body: []byte(m.Body)}
r := &http.Response{
Request: ctx.Request,
Header: ctx.Response.Header,
Close: ctx.Response.Close,
ContentLength: ctx.Response.ContentLength,
Trailer: ctx.Response.Trailer,
TLS: ctx.Response.TLS,
TransferEncoding: ctx.Response.TransferEncoding,
Status: ctx.Response.Status,
StatusCode: ctx.Response.StatusCode,
Proto: ctx.Response.Proto,
ProtoMajor: ctx.Response.ProtoMajor,
ProtoMinor: ctx.Response.ProtoMinor,
Body: cl,
}
log.Debug("Injecting HTTP Response Body with %s", log.Colorize(log.BLUE, m.Body))
*ctx.Response = *r
}
// Set Headers
for k, v := range m.Headers {
key := strings.ToTitle(strings.Replace(k, "_", "-", -1))
log.Debug("Spoofing Header %s => %s", log.Colorize(log.LIGHTMAGENTA, key), v)
ctx.Response.Header.Add(key, v)
ctx.ResponseWriter.Header().Add(key, v)
}
// This Writes all headers, setting status code - so call this last
ctx.Response.StatusCode = m.Status
ctx.Response.Status = http.StatusText(m.Status)
ctx.ResponseWriter.WriteHeader(m.Status)
}
}
func Index(w http.ResponseWriter, r *http.Request) {
var err error
var tmpl plate.Template
params := r.URL.Query()
error := params.Get(":error")
error, _ = url.QueryUnescape(error)
server := plate.NewServer()
tmpl, err = server.Template(w)
if err != nil {
plate.Serve404(w, err.Error())
return
}
tmpl.Bag["Error"] = strings.ToTitle(error)
tmpl.Template = "templates/auth/in.html"
tmpl.DisplayTemplate()
}
func MessThingPronounsubMethod(state *lua.State, thing *Thing) int {
state.PushGoFunction(func(state *lua.State) int {
thing := checkThing(state, 1)
text := state.CheckString(2)
for code, pronoun := range thing.Pronouns() {
lowerCode := fmt.Sprintf(`%%%s`, code)
upperCode := fmt.Sprintf(`%%%s`, strings.ToUpper(code))
text = strings.Replace(text, lowerCode, pronoun, -1)
text = strings.Replace(text, upperCode, strings.ToTitle(pronoun), -1)
}
text = strings.Replace(text, `%n`, thing.Name, -1)
text = strings.Replace(text, `%N`, thing.Name, -1)
state.Pop(2) // ( udataThing str -- )
state.PushString(text) // ( -- str' )
return 1
})
return 1
}
func (h *Handler) renderTemplate(w http.ResponseWriter, r *http.Request, category, slug string) {
page, err := query(h.dbConn, category, slug)
if err != nil {
writeError(w, r, err.Error())
return
}
page.URL = r.URL.String()
if slug == "" && len(page.Snippets) == 0 {
writeError(w, r, fmt.Sprintf("no snippets found for category (%s)", category))
return
}
// render the template
lp := path.Join(templateDir, "layout.html")
// set up custom functions
funcMap := template.FuncMap{
"stripSlashes": func(s string) string {
return strings.Replace(s, "/", "", -1)
},
"stripTags": func(s string) string {
reHTML := regexp.MustCompile(`<.+>`)
return reHTML.ReplaceAllString(s, "")
},
"toTitle": func(s string) string {
return strings.ToTitle(s)
},
"toUppercase": func(s string) string {
return strings.ToUpper(s)
},
}
// parse & execute the template
tmpl := template.Must(template.New("").Funcs(funcMap).ParseFiles(lp))
if err := tmpl.ExecuteTemplate(w, "layout", page); err != nil {
writeError(w, r, fmt.Sprintf("execute template failed: %v", err))
return
}
}