14768173832

Committed 01 May 2025 02:03AM UTC coverage: 79.722% (+0.2%) from 79.532%

Build # 14768173832

Build Type

push

github

Committed by

stackus

Commit Message

update documentation

Run Details

2693 of 3378 relevant lines covered (79.72%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.67

/compiler/tokens.go

package compiler

import (
        "fmt"
)

type tokenType int

type token struct {
        typ  tokenType
        lit  string
        line int
        col  int
}

const (
        // General tokens
        tEOF tokenType = iota
        tError
        tRoot
        tNewLine
        tPackage
        tImport
        tGoCode

        // Template tokens
        tTemplateStart
        tTemplateEnd

        // Goht/Haml tokens
        tDoctype
        tTag
        tId
        tClass
        tObjectRef
        tAttrName
        tAttrOperator
        tAttrEscapedValue
        tAttrDynamicValue
        tIndent
        tComment
        tRubyComment
        tVoidTag
        tKeepNewlines
        tNukeInnerWhitespace
        tNukeOuterWhitespace
        tAddWhitespaceBefore
        tAddWhitespaceAfter
        tRawText
        tEscapedText
        tDynamicText
        tPlainText
        tPreserveText
        tUnescaped
        tScript
        tSilentScript
        tRenderCommand
        tChildrenCommand
        tSlotCommand
        tAttributesCommand
        tFilterStart
        tFilterEnd
)

func (t tokenType) String() string {
        switch t {
        case tEOF:
                return "EOF"
        case tError:
                return "Error"
        case tRoot:
                return "Root"
        case tNewLine:
                return "NewLine"
        case tPackage:
                return "Package"
        case tImport:
                return "Import"
        case tGoCode:
                return "GoCode"
        case tTemplateStart:
                return "TemplateStart"
        case tTemplateEnd:
                return "TemplateEnd"
        case tDoctype:
                return "Doctype"
        case tTag:
                return "Tag"
        case tId:
                return "Id"
        case tClass:
                return "Class"
        case tObjectRef:
                return "ObjectRef"
        case tAttrName:
                return "AttrName"
        case tAttrOperator:
                return "AttrOperator"
        case tAttrEscapedValue:
                return "AttrEscapedValue"
        case tAttrDynamicValue:
                return "AttrDynamicValue"
        case tIndent:
                return "Indent"
        case tComment:
                return "Comment"
        case tRubyComment:
                return "RubyComment"
        case tVoidTag:
                return "VoidTag"
        case tKeepNewlines:
                return "KeepNewlines"
        case tNukeInnerWhitespace:
                return "NukeInnerWhitespace"
        case tNukeOuterWhitespace:
                return "NukeOuterWhitespace"
        case tAddWhitespaceBefore:
                return "AddWhitespaceBefore"
        case tAddWhitespaceAfter:
                return "AddWhitespaceAfter"
        case tRawText:
                return "RawText"
        case tEscapedText:
                return "EscapedText"
        case tDynamicText:
                return "DynamicText"
        case tPlainText:
                return "PlainText"
        case tPreserveText:
                return "PreserveText"
        case tUnescaped:
                return "Unescaped"
        case tScript:
                return "Script"
        case tSilentScript:
                return "SilentScript"
        case tRenderCommand:
                return "RenderCommand"
        case tChildrenCommand:
                return "ChildrenCommand"
        case tSlotCommand:
                return "SlotCommand"
        case tAttributesCommand:
                return "AttributesCommand"
        case tFilterStart:
                return "FilterStart"
        case tFilterEnd:
                return "FilterEnd"
        default:
                return "!Unknown!"
        }
}

func (t token) Type() tokenType {
        return t.typ
}

func (t token) Lit() string {
        return t.lit
}

func (t token) Line() int {
        return t.line
}

func (t token) Col() int {
        return t.col
}

func (t token) String() string {
        if t.typ != tError && len(t.lit) > 30 {
                return fmt.Sprintf("%s[%d:%d]: %q", t.typ, t.line, t.col, string([]rune(t.lit)[:30])+"...")
        }
        return fmt.Sprintf("%s[%d:%d]: %q", t.typ, t.line, t.col, t.lit)
}

1	package compiler
2
3	import (
4	"fmt"
5	)
6
7	type tokenType int
8
9	type token struct {
10	typ tokenType
11	lit string
12	line int
13	col int
14	}
15
16	const (
17	// General tokens
18	tEOF tokenType = iota
19	tError
20	tRoot
21	tNewLine
22	tPackage
23	tImport
24	tGoCode
25
26	// Template tokens
27	tTemplateStart
28	tTemplateEnd
29
30	// Goht/Haml tokens
31	tDoctype
32	tTag
33	tId
34	tClass
35	tObjectRef
36	tAttrName
37	tAttrOperator
38	tAttrEscapedValue
39	tAttrDynamicValue
40	tIndent
41	tComment
42	tRubyComment
43	tVoidTag
44	tKeepNewlines
45	tNukeInnerWhitespace
46	tNukeOuterWhitespace
47	tAddWhitespaceBefore
48	tAddWhitespaceAfter
49	tRawText
50	tEscapedText
51	tDynamicText
52	tPlainText
53	tPreserveText
54	tUnescaped
55	tScript
56	tSilentScript
57	tRenderCommand
58	tChildrenCommand
59	tSlotCommand
60	tAttributesCommand
61	tFilterStart
62	tFilterEnd
63	)
64
65	func (t tokenType) String() string {	1✔
66	switch t {	1✔
67	case tEOF:	1✔
68	return "EOF"	1✔
69	case tError:	1✔
70	return "Error"	1✔
71	case tRoot:	1✔
72	return "Root"	1✔
73	case tNewLine:	1✔
74	return "NewLine"	1✔
75	case tPackage:	1✔
76	return "Package"	1✔
77	case tImport:	1✔
78	return "Import"	1✔
79	case tGoCode:	1✔
80	return "GoCode"	1✔
81	case tTemplateStart:	×
82	return "TemplateStart"	×
83	case tTemplateEnd:	×
84	return "TemplateEnd"	×
85	case tDoctype:	1✔
86	return "Doctype"	1✔
87	case tTag:	1✔
88	return "Tag"	1✔
89	case tId:	1✔
90	return "Id"	1✔
91	case tClass:	1✔
92	return "Class"	1✔
93	case tObjectRef:	1✔
94	return "ObjectRef"	1✔
95	case tAttrName:	1✔
96	return "AttrName"	1✔
97	case tAttrOperator:	1✔
98	return "AttrOperator"	1✔
99	case tAttrEscapedValue:	1✔
100	return "AttrEscapedValue"	1✔
101	case tAttrDynamicValue:	1✔
102	return "AttrDynamicValue"	1✔
103	case tIndent:	1✔
104	return "Indent"	1✔
105	case tComment:	1✔
106	return "Comment"	1✔
107	case tRubyComment:	1✔
108	return "RubyComment"	1✔
109	case tVoidTag:	1✔
110	return "VoidTag"	1✔
111	case tKeepNewlines:	×
112	return "KeepNewlines"	×
113	case tNukeInnerWhitespace:	1✔
114	return "NukeInnerWhitespace"	1✔
115	case tNukeOuterWhitespace:	1✔
116	return "NukeOuterWhitespace"	1✔
117	case tAddWhitespaceBefore:	×
118	return "AddWhitespaceBefore"	×
119	case tAddWhitespaceAfter:	×
120	return "AddWhitespaceAfter"	×
121	case tRawText:	×
122	return "RawText"	×
123	case tEscapedText:	1✔
124	return "EscapedText"	1✔
125	case tDynamicText:	1✔
126	return "DynamicText"	1✔
127	case tPlainText:	1✔
128	return "PlainText"	1✔
129	case tPreserveText:	1✔
130	return "PreserveText"	1✔
131	case tUnescaped:	1✔
132	return "Unescaped"	1✔
133	case tScript:	1✔
134	return "Script"	1✔
135	case tSilentScript:	1✔
136	return "SilentScript"	1✔
137	case tRenderCommand:	1✔
138	return "RenderCommand"	1✔
139	case tChildrenCommand:	1✔
140	return "ChildrenCommand"	1✔
141	case tSlotCommand:	×
142	return "SlotCommand"	×
143	case tAttributesCommand:	1✔
144	return "AttributesCommand"	1✔
145	case tFilterStart:	1✔
146	return "FilterStart"	1✔
147	case tFilterEnd:	1✔
148	return "FilterEnd"	1✔
149	default:	1✔
150	return "!Unknown!"	1✔
151	}
152	}
153
154	func (t token) Type() tokenType {	1✔
155	return t.typ	1✔
156	}	1✔
157
158	func (t token) Lit() string {	×
159	return t.lit	×
160	}	×
161
162	func (t token) Line() int {	×
163	return t.line	×
164	}	×
165
166	func (t token) Col() int {	×
167	return t.col	×
168	}	×
169
170	func (t token) String() string {	1✔
171	if t.typ != tError && len(t.lit) > 30 {	2✔
172	return fmt.Sprintf("%s[%d:%d]: %q", t.typ, t.line, t.col, string([]rune(t.lit)[:30])+"...")	1✔
173	}	1✔
174	return fmt.Sprintf("%s[%d:%d]: %q", t.typ, t.line, t.col, t.lit)	1✔
175	}

stackus / goht / 14768173832

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous