id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
15,600 | ikawaha/kagome | internal/dic/connection.go | LoadConnectionTable | func LoadConnectionTable(r io.Reader) (t ConnectionTable, err error) {
if err = binary.Read(r, binary.LittleEndian, &t.Row); err != nil {
return
}
if err = binary.Read(r, binary.LittleEndian, &t.Col); err != nil {
return
}
t.Vec = make([]int16, t.Row*t.Col)
for i := range t.Vec {
if err = binary.Read(r, binary.LittleEndian, &t.Vec[i]); err != nil {
return
}
}
return
} | go | func LoadConnectionTable(r io.Reader) (t ConnectionTable, err error) {
if err = binary.Read(r, binary.LittleEndian, &t.Row); err != nil {
return
}
if err = binary.Read(r, binary.LittleEndian, &t.Col); err != nil {
return
}
t.Vec = make([]int16, t.Row*t.Col)
for i := range t.Vec {
if err = binary.Read(r, binary.LittleEndian, &t.Vec[i]); err != nil {
return
}
}
return
} | [
"func",
"LoadConnectionTable",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"t",
"ConnectionTable",
",",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"t",
".",
"Row",
")",
";... | // LoadConnectionTable loads ConnectionTable from io.Reader. | [
"LoadConnectionTable",
"loads",
"ConnectionTable",
"from",
"io",
".",
"Reader",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/dic/connection.go#L53-L67 |
15,601 | ikawaha/kagome | internal/lattice/lattice.go | New | func New(d *dic.Dic, u *dic.UserDic) *Lattice {
la := latticePool.Get().(*Lattice)
la.dic = d
la.udic = u
return la
} | go | func New(d *dic.Dic, u *dic.UserDic) *Lattice {
la := latticePool.Get().(*Lattice)
la.dic = d
la.udic = u
return la
} | [
"func",
"New",
"(",
"d",
"*",
"dic",
".",
"Dic",
",",
"u",
"*",
"dic",
".",
"UserDic",
")",
"*",
"Lattice",
"{",
"la",
":=",
"latticePool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"Lattice",
")",
"\n",
"la",
".",
"dic",
"=",
"d",
"\n",
"la",
"... | // New returns a new lattice. | [
"New",
"returns",
"a",
"new",
"lattice",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L65-L70 |
15,602 | ikawaha/kagome | internal/lattice/lattice.go | Free | func (la *Lattice) Free() {
la.Input = ""
la.Output = la.Output[:0]
for i := range la.list {
for j := range la.list[i] {
nodePool.Put(la.list[i][j])
}
la.list[i] = la.list[i][:0]
}
la.list = la.list[:0]
la.udic = nil
latticePool.Put(la)
} | go | func (la *Lattice) Free() {
la.Input = ""
la.Output = la.Output[:0]
for i := range la.list {
for j := range la.list[i] {
nodePool.Put(la.list[i][j])
}
la.list[i] = la.list[i][:0]
}
la.list = la.list[:0]
la.udic = nil
latticePool.Put(la)
} | [
"func",
"(",
"la",
"*",
"Lattice",
")",
"Free",
"(",
")",
"{",
"la",
".",
"Input",
"=",
"\"",
"\"",
"\n",
"la",
".",
"Output",
"=",
"la",
".",
"Output",
"[",
":",
"0",
"]",
"\n",
"for",
"i",
":=",
"range",
"la",
".",
"list",
"{",
"for",
"j"... | // Free releases a memory of a lattice. | [
"Free",
"releases",
"a",
"memory",
"of",
"a",
"lattice",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L73-L85 |
15,603 | ikawaha/kagome | internal/lattice/lattice.go | String | func (la *Lattice) String() string {
str := ""
for i, nodes := range la.list {
str += fmt.Sprintf("[%v] :\n", i)
for _, node := range nodes {
str += fmt.Sprintf("%v\n", node)
}
str += "\n"
}
return str
} | go | func (la *Lattice) String() string {
str := ""
for i, nodes := range la.list {
str += fmt.Sprintf("[%v] :\n", i)
for _, node := range nodes {
str += fmt.Sprintf("%v\n", node)
}
str += "\n"
}
return str
} | [
"func",
"(",
"la",
"*",
"Lattice",
")",
"String",
"(",
")",
"string",
"{",
"str",
":=",
"\"",
"\"",
"\n",
"for",
"i",
",",
"nodes",
":=",
"range",
"la",
".",
"list",
"{",
"str",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"i",
"... | // String returns a debug string of a lattice. | [
"String",
"returns",
"a",
"debug",
"string",
"of",
"a",
"lattice",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L186-L196 |
15,604 | ikawaha/kagome | internal/lattice/lattice.go | Forward | func (la *Lattice) Forward(m TokenizeMode) {
for i, size := 1, len(la.list); i < size; i++ {
currentList := la.list[i]
for index, target := range currentList {
prevList := la.list[target.Start]
if len(prevList) == 0 {
la.list[i][index].Cost = maximumCost
continue
}
for j, n := range prevList {
var c int16
if n.Class != USER && target.Class != USER {
c = la.dic.Connection.At(int(n.Right), int(target.Left))
}
totalCost := int64(c) + int64(target.Weight) + int64(n.Cost)
if m != Normal {
totalCost += int64(additionalCost(n))
}
if totalCost > maximumCost {
totalCost = maximumCost
}
if j == 0 || int32(totalCost) < la.list[i][index].Cost {
la.list[i][index].Cost = int32(totalCost)
la.list[i][index].Prev = la.list[target.Start][j]
}
}
}
}
return
} | go | func (la *Lattice) Forward(m TokenizeMode) {
for i, size := 1, len(la.list); i < size; i++ {
currentList := la.list[i]
for index, target := range currentList {
prevList := la.list[target.Start]
if len(prevList) == 0 {
la.list[i][index].Cost = maximumCost
continue
}
for j, n := range prevList {
var c int16
if n.Class != USER && target.Class != USER {
c = la.dic.Connection.At(int(n.Right), int(target.Left))
}
totalCost := int64(c) + int64(target.Weight) + int64(n.Cost)
if m != Normal {
totalCost += int64(additionalCost(n))
}
if totalCost > maximumCost {
totalCost = maximumCost
}
if j == 0 || int32(totalCost) < la.list[i][index].Cost {
la.list[i][index].Cost = int32(totalCost)
la.list[i][index].Prev = la.list[target.Start][j]
}
}
}
}
return
} | [
"func",
"(",
"la",
"*",
"Lattice",
")",
"Forward",
"(",
"m",
"TokenizeMode",
")",
"{",
"for",
"i",
",",
"size",
":=",
"1",
",",
"len",
"(",
"la",
".",
"list",
")",
";",
"i",
"<",
"size",
";",
"i",
"++",
"{",
"currentList",
":=",
"la",
".",
"l... | // Forward runs forward algorithm of the Viterbi. | [
"Forward",
"runs",
"forward",
"algorithm",
"of",
"the",
"Viterbi",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L219-L248 |
15,605 | ikawaha/kagome | internal/lattice/lattice.go | Backward | func (la *Lattice) Backward(m TokenizeMode) {
const bufferExpandRatio = 2
size := len(la.list)
if size == 0 {
return
}
if cap(la.Output) < size {
la.Output = make([]*node, 0, size*bufferExpandRatio)
} else {
la.Output = la.Output[:0]
}
for p := la.list[size-1][0]; p != nil; p = p.Prev {
if m != Extended || p.Class != UNKNOWN {
la.Output = append(la.Output, p)
continue
}
runeLen := utf8.RuneCountInString(p.Surface)
stack := make([]*node, 0, runeLen)
i := 0
for _, r := range p.Surface {
n := nodePool.Get().(*node)
n.ID = p.ID
n.Start = p.Start + i
n.Class = DUMMY
n.Surface = string(r)
stack = append(stack, n)
i++
}
for j, end := 0, len(stack); j < end; j++ {
la.Output = append(la.Output, stack[runeLen-1-j])
}
}
} | go | func (la *Lattice) Backward(m TokenizeMode) {
const bufferExpandRatio = 2
size := len(la.list)
if size == 0 {
return
}
if cap(la.Output) < size {
la.Output = make([]*node, 0, size*bufferExpandRatio)
} else {
la.Output = la.Output[:0]
}
for p := la.list[size-1][0]; p != nil; p = p.Prev {
if m != Extended || p.Class != UNKNOWN {
la.Output = append(la.Output, p)
continue
}
runeLen := utf8.RuneCountInString(p.Surface)
stack := make([]*node, 0, runeLen)
i := 0
for _, r := range p.Surface {
n := nodePool.Get().(*node)
n.ID = p.ID
n.Start = p.Start + i
n.Class = DUMMY
n.Surface = string(r)
stack = append(stack, n)
i++
}
for j, end := 0, len(stack); j < end; j++ {
la.Output = append(la.Output, stack[runeLen-1-j])
}
}
} | [
"func",
"(",
"la",
"*",
"Lattice",
")",
"Backward",
"(",
"m",
"TokenizeMode",
")",
"{",
"const",
"bufferExpandRatio",
"=",
"2",
"\n",
"size",
":=",
"len",
"(",
"la",
".",
"list",
")",
"\n",
"if",
"size",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
... | // Backward runs backward algorithm of the Viterbi. | [
"Backward",
"runs",
"backward",
"algorithm",
"of",
"the",
"Viterbi",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L251-L283 |
15,606 | ikawaha/kagome | internal/lattice/lattice.go | Dot | func (la *Lattice) Dot(w io.Writer) {
bests := make(map[*node]struct{})
for _, n := range la.Output {
bests[n] = struct{}{}
}
type edge struct {
from *node
to *node
}
edges := make([]edge, 0, 1024)
for i, size := 1, len(la.list); i < size; i++ {
currents := la.list[i]
for _, to := range currents {
if to.Class == UNKNOWN {
if _, ok := bests[to]; !ok {
continue
}
}
prevs := la.list[to.Start]
if len(prevs) == 0 {
continue
}
for _, from := range prevs {
if from.Class == UNKNOWN {
if _, ok := bests[from]; !ok {
continue
}
}
edges = append(edges, edge{from, to})
}
}
}
fmt.Fprintln(w, "graph lattice {")
fmt.Fprintln(w, "dpi=48;")
fmt.Fprintln(w, "graph [style=filled, splines=true, overlap=false, fontsize=30, rankdir=LR]")
fmt.Fprintln(w, "edge [fontname=Helvetica, fontcolor=red, color=\"#606060\"]")
fmt.Fprintln(w, "node [shape=box, style=filled, fillcolor=\"#e8e8f0\", fontname=Helvetica]")
for i, list := range la.list {
for _, n := range list {
if n.Class == UNKNOWN {
if _, ok := bests[n]; !ok {
continue
}
}
surf := n.Surface
if n.ID == BosEosID {
if i == 0 {
surf = "BOS"
} else {
surf = "EOS"
}
}
features := features(la.dic, la.udic, n)
pos := "---"
if len(features) > 1 {
pos = features[0]
}
if _, ok := bests[n]; ok {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\",shape=ellipse, peripheries=2];\n", n, surf, pos, n.Weight)
} else if n.Class != UNKNOWN {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\"];\n", n, surf, pos, n.Weight)
}
}
}
for _, e := range edges {
var c int16
if e.from.Class != USER && e.to.Class != USER {
c = la.dic.Connection.At(int(e.from.Right), int(e.to.Left))
}
_, l := bests[e.from]
_, r := bests[e.to]
if l && r {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\", style=bold, color=blue, fontcolor=blue];\n",
e.from, e.to, c)
} else {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\"];\n",
e.from, e.to, c)
}
}
fmt.Fprintln(w, "}")
} | go | func (la *Lattice) Dot(w io.Writer) {
bests := make(map[*node]struct{})
for _, n := range la.Output {
bests[n] = struct{}{}
}
type edge struct {
from *node
to *node
}
edges := make([]edge, 0, 1024)
for i, size := 1, len(la.list); i < size; i++ {
currents := la.list[i]
for _, to := range currents {
if to.Class == UNKNOWN {
if _, ok := bests[to]; !ok {
continue
}
}
prevs := la.list[to.Start]
if len(prevs) == 0 {
continue
}
for _, from := range prevs {
if from.Class == UNKNOWN {
if _, ok := bests[from]; !ok {
continue
}
}
edges = append(edges, edge{from, to})
}
}
}
fmt.Fprintln(w, "graph lattice {")
fmt.Fprintln(w, "dpi=48;")
fmt.Fprintln(w, "graph [style=filled, splines=true, overlap=false, fontsize=30, rankdir=LR]")
fmt.Fprintln(w, "edge [fontname=Helvetica, fontcolor=red, color=\"#606060\"]")
fmt.Fprintln(w, "node [shape=box, style=filled, fillcolor=\"#e8e8f0\", fontname=Helvetica]")
for i, list := range la.list {
for _, n := range list {
if n.Class == UNKNOWN {
if _, ok := bests[n]; !ok {
continue
}
}
surf := n.Surface
if n.ID == BosEosID {
if i == 0 {
surf = "BOS"
} else {
surf = "EOS"
}
}
features := features(la.dic, la.udic, n)
pos := "---"
if len(features) > 1 {
pos = features[0]
}
if _, ok := bests[n]; ok {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\",shape=ellipse, peripheries=2];\n", n, surf, pos, n.Weight)
} else if n.Class != UNKNOWN {
fmt.Fprintf(w, "\t\"%p\" [label=\"%s\\n%s\\n%d\"];\n", n, surf, pos, n.Weight)
}
}
}
for _, e := range edges {
var c int16
if e.from.Class != USER && e.to.Class != USER {
c = la.dic.Connection.At(int(e.from.Right), int(e.to.Left))
}
_, l := bests[e.from]
_, r := bests[e.to]
if l && r {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\", style=bold, color=blue, fontcolor=blue];\n",
e.from, e.to, c)
} else {
fmt.Fprintf(w, "\t\"%p\" -- \"%p\" [label=\"%d\"];\n",
e.from, e.to, c)
}
}
fmt.Fprintln(w, "}")
} | [
"func",
"(",
"la",
"*",
"Lattice",
")",
"Dot",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"bests",
":=",
"make",
"(",
"map",
"[",
"*",
"node",
"]",
"struct",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"la",
".",
"Output",
"{",
... | // Dot outputs the lattice in the graphviz dot format. | [
"Dot",
"outputs",
"the",
"lattice",
"in",
"the",
"graphviz",
"dot",
"format",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/lattice/lattice.go#L318-L399 |
15,607 | ikawaha/kagome | tokenizer/token.go | Features | func (t Token) Features() []string {
switch lattice.NodeClass(t.Class) {
case lattice.DUMMY:
return nil
case lattice.KNOWN:
var c int
if t.dic.Contents != nil {
c = len(t.dic.Contents[t.ID])
}
features := make([]string, 0, len(t.dic.POSTable.POSs[t.ID])+c)
for _, id := range t.dic.POSTable.POSs[t.ID] {
features = append(features, t.dic.POSTable.NameList[id])
}
if t.dic.Contents != nil {
features = append(features, t.dic.Contents[t.ID]...)
}
return features
case lattice.UNKNOWN:
features := make([]string, len(t.dic.UnkContents[t.ID]))
for i := range t.dic.UnkContents[t.ID] {
features[i] = t.dic.UnkContents[t.ID][i]
}
return features
case lattice.USER:
pos := t.udic.Contents[t.ID].Pos
tokens := strings.Join(t.udic.Contents[t.ID].Tokens, "/")
yomi := strings.Join(t.udic.Contents[t.ID].Yomi, "/")
return []string{pos, tokens, yomi}
}
return nil
} | go | func (t Token) Features() []string {
switch lattice.NodeClass(t.Class) {
case lattice.DUMMY:
return nil
case lattice.KNOWN:
var c int
if t.dic.Contents != nil {
c = len(t.dic.Contents[t.ID])
}
features := make([]string, 0, len(t.dic.POSTable.POSs[t.ID])+c)
for _, id := range t.dic.POSTable.POSs[t.ID] {
features = append(features, t.dic.POSTable.NameList[id])
}
if t.dic.Contents != nil {
features = append(features, t.dic.Contents[t.ID]...)
}
return features
case lattice.UNKNOWN:
features := make([]string, len(t.dic.UnkContents[t.ID]))
for i := range t.dic.UnkContents[t.ID] {
features[i] = t.dic.UnkContents[t.ID][i]
}
return features
case lattice.USER:
pos := t.udic.Contents[t.ID].Pos
tokens := strings.Join(t.udic.Contents[t.ID].Tokens, "/")
yomi := strings.Join(t.udic.Contents[t.ID].Yomi, "/")
return []string{pos, tokens, yomi}
}
return nil
} | [
"func",
"(",
"t",
"Token",
")",
"Features",
"(",
")",
"[",
"]",
"string",
"{",
"switch",
"lattice",
".",
"NodeClass",
"(",
"t",
".",
"Class",
")",
"{",
"case",
"lattice",
".",
"DUMMY",
":",
"return",
"nil",
"\n",
"case",
"lattice",
".",
"KNOWN",
":... | // Features returns contents of a token. | [
"Features",
"returns",
"contents",
"of",
"a",
"token",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/tokenizer/token.go#L66-L96 |
15,608 | ikawaha/kagome | tokenizer/token.go | Pos | func (t Token) Pos() string {
f := t.Features()
if len(f) < 1 {
return ""
}
return f[0]
} | go | func (t Token) Pos() string {
f := t.Features()
if len(f) < 1 {
return ""
}
return f[0]
} | [
"func",
"(",
"t",
"Token",
")",
"Pos",
"(",
")",
"string",
"{",
"f",
":=",
"t",
".",
"Features",
"(",
")",
"\n",
"if",
"len",
"(",
"f",
")",
"<",
"1",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"f",
"[",
"0",
"]",
"\n",
"}"
] | // Pos returns the first element of features. | [
"Pos",
"returns",
"the",
"first",
"element",
"of",
"features",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/tokenizer/token.go#L99-L105 |
15,609 | ikawaha/kagome | tokenizer/token.go | String | func (t Token) String() string {
return fmt.Sprintf("%v(%v, %v)%v[%v]", t.Surface, t.Start, t.End, t.Class, t.ID)
} | go | func (t Token) String() string {
return fmt.Sprintf("%v(%v, %v)%v[%v]", t.Surface, t.Start, t.End, t.Class, t.ID)
} | [
"func",
"(",
"t",
"Token",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"Surface",
",",
"t",
".",
"Start",
",",
"t",
".",
"End",
",",
"t",
".",
"Class",
",",
"t",
".",
"ID",
")",
"... | // String returns a string representation of a token. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"a",
"token",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/tokenizer/token.go#L108-L110 |
15,610 | ikawaha/kagome | tokenizer/dic.go | NewDic | func NewDic(path string) (Dic, error) {
d, err := dic.Load(path)
return Dic{d}, err
} | go | func NewDic(path string) (Dic, error) {
d, err := dic.Load(path)
return Dic{d}, err
} | [
"func",
"NewDic",
"(",
"path",
"string",
")",
"(",
"Dic",
",",
"error",
")",
"{",
"d",
",",
"err",
":=",
"dic",
".",
"Load",
"(",
"path",
")",
"\n",
"return",
"Dic",
"{",
"d",
"}",
",",
"err",
"\n",
"}"
] | // NewDic loads a dictionary from a file. | [
"NewDic",
"loads",
"a",
"dictionary",
"from",
"a",
"file",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/tokenizer/dic.go#L55-L58 |
15,611 | ikawaha/kagome | internal/dic/unkdic.go | ReadUnkDic | func ReadUnkDic(r io.Reader) (UnkDic, error) {
d := UnkDic{}
ui, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndex: %v", err)
}
d.UnkIndex = ui
ud, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndexDup: %v", err)
}
d.UnkIndexDup = ud
dec := gob.NewDecoder(r)
if err := dec.Decode(&d.UnkMorphs); err != nil {
return d, fmt.Errorf("UnkMorphs: %v", err)
}
if err := dec.Decode(&d.UnkContents); err != nil {
return d, fmt.Errorf("UnkContents: %v", err)
}
return d, nil
} | go | func ReadUnkDic(r io.Reader) (UnkDic, error) {
d := UnkDic{}
ui, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndex: %v", err)
}
d.UnkIndex = ui
ud, err := readMap(r)
if err != nil {
return d, fmt.Errorf("UnkIndexDup: %v", err)
}
d.UnkIndexDup = ud
dec := gob.NewDecoder(r)
if err := dec.Decode(&d.UnkMorphs); err != nil {
return d, fmt.Errorf("UnkMorphs: %v", err)
}
if err := dec.Decode(&d.UnkContents); err != nil {
return d, fmt.Errorf("UnkContents: %v", err)
}
return d, nil
} | [
"func",
"ReadUnkDic",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"UnkDic",
",",
"error",
")",
"{",
"d",
":=",
"UnkDic",
"{",
"}",
"\n",
"ui",
",",
"err",
":=",
"readMap",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"d",
",",
"... | // ReadUnkDic loads an unknown word dictionary. | [
"ReadUnkDic",
"loads",
"an",
"unknown",
"word",
"dictionary",
"."
] | d76ce24c16d24bc8968d32681d92db4d7ff6bd2d | https://github.com/ikawaha/kagome/blob/d76ce24c16d24bc8968d32681d92db4d7ff6bd2d/internal/dic/unkdic.go#L117-L138 |
15,612 | wellington/go-libsass | options.go | Option | func (c *sass) Option(opts ...option) error {
for _, opt := range opts {
err := opt(c)
if err != nil {
return err
}
}
return nil
} | go | func (c *sass) Option(opts ...option) error {
for _, opt := range opts {
err := opt(c)
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"sass",
")",
"Option",
"(",
"opts",
"...",
"option",
")",
"error",
"{",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"err",
":=",
"opt",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
... | // Option allows the modifying of internal compiler state | [
"Option",
"allows",
"the",
"modifying",
"of",
"internal",
"compiler",
"state"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L8-L16 |
15,613 | wellington/go-libsass | options.go | BasePath | func BasePath(basePath string) option {
return func(c *sass) error {
c.httpPath = basePath
// FIXME: remove from context
c.ctx.HTTPPath = basePath
return nil
}
} | go | func BasePath(basePath string) option {
return func(c *sass) error {
c.httpPath = basePath
// FIXME: remove from context
c.ctx.HTTPPath = basePath
return nil
}
} | [
"func",
"BasePath",
"(",
"basePath",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"httpPath",
"=",
"basePath",
"\n",
"// FIXME: remove from context",
"c",
".",
"ctx",
".",
"HTTPPath",
"=",
"basePath",
... | // BasePath sets the internal path provided to handlers requiring
// a base path for http calls. This is useful for hosted solutions
// that need to provided absolute paths to assets. | [
"BasePath",
"sets",
"the",
"internal",
"path",
"provided",
"to",
"handlers",
"requiring",
"a",
"base",
"path",
"for",
"http",
"calls",
".",
"This",
"is",
"useful",
"for",
"hosted",
"solutions",
"that",
"need",
"to",
"provided",
"absolute",
"paths",
"to",
"as... | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L21-L28 |
15,614 | wellington/go-libsass | options.go | BuildDir | func BuildDir(path string) option {
return func(c *sass) error {
c.ctx.BuildDir = path
return nil
}
} | go | func BuildDir(path string) option {
return func(c *sass) error {
c.ctx.BuildDir = path
return nil
}
} | [
"func",
"BuildDir",
"(",
"path",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"BuildDir",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // BuildDir only used for spriting, how terrible! | [
"BuildDir",
"only",
"used",
"for",
"spriting",
"how",
"terrible!"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L31-L36 |
15,615 | wellington/go-libsass | options.go | CacheBust | func CacheBust(t string) option {
return func(c *sass) error {
if t == "ts" {
t = "timestamp"
}
c.cachebust = t
return nil
}
} | go | func CacheBust(t string) option {
return func(c *sass) error {
if t == "ts" {
t = "timestamp"
}
c.cachebust = t
return nil
}
} | [
"func",
"CacheBust",
"(",
"t",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"if",
"t",
"==",
"\"",
"\"",
"{",
"t",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"c",
".",
"cachebust",
"=",
"t",
"\n",
"return",
... | // CacheBust append timestamps to static assets to prevent caching | [
"CacheBust",
"append",
"timestamps",
"to",
"static",
"assets",
"to",
"prevent",
"caching"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L39-L47 |
15,616 | wellington/go-libsass | options.go | Comments | func Comments(b bool) option {
return func(c *sass) error {
c.ctx.Comments = b
return nil
}
} | go | func Comments(b bool) option {
return func(c *sass) error {
c.ctx.Comments = b
return nil
}
} | [
"func",
"Comments",
"(",
"b",
"bool",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"Comments",
"=",
"b",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Comments toggles whether comments should be included in the output | [
"Comments",
"toggles",
"whether",
"comments",
"should",
"be",
"included",
"in",
"the",
"output"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L50-L55 |
15,617 | wellington/go-libsass | options.go | HTTPPath | func HTTPPath(u string) option {
return func(c *sass) error {
c.httpPath = u
c.ctx.HTTPPath = u
return nil
}
} | go | func HTTPPath(u string) option {
return func(c *sass) error {
c.httpPath = u
c.ctx.HTTPPath = u
return nil
}
} | [
"func",
"HTTPPath",
"(",
"u",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"httpPath",
"=",
"u",
"\n",
"c",
".",
"ctx",
".",
"HTTPPath",
"=",
"u",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}... | // HTTPPath prefixes all sprites and generated images with this uri.
// Enabling wellington to serve images when used in HTTP mode | [
"HTTPPath",
"prefixes",
"all",
"sprites",
"and",
"generated",
"images",
"with",
"this",
"uri",
".",
"Enabling",
"wellington",
"to",
"serve",
"images",
"when",
"used",
"in",
"HTTP",
"mode"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L67-L73 |
15,618 | wellington/go-libsass | options.go | ImgBuildDir | func ImgBuildDir(path string) option {
return func(c *sass) error {
c.ctx.GenImgDir = path
return nil
}
} | go | func ImgBuildDir(path string) option {
return func(c *sass) error {
c.ctx.GenImgDir = path
return nil
}
} | [
"func",
"ImgBuildDir",
"(",
"path",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"GenImgDir",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ImgBuildDir specifies the destination directory for images | [
"ImgBuildDir",
"specifies",
"the",
"destination",
"directory",
"for",
"images"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L76-L81 |
15,619 | wellington/go-libsass | options.go | ImgDir | func ImgDir(path string) option {
return func(c *sass) error {
c.ctx.ImageDir = path
return nil
}
} | go | func ImgDir(path string) option {
return func(c *sass) error {
c.ctx.ImageDir = path
return nil
}
} | [
"func",
"ImgDir",
"(",
"path",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"ImageDir",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ImgDir specifies where to locate images for spriting | [
"ImgDir",
"specifies",
"where",
"to",
"locate",
"images",
"for",
"spriting"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L84-L89 |
15,620 | wellington/go-libsass | options.go | ImportsOption | func ImportsOption(imports *Imports) option {
return func(c *sass) error {
c.ctx.Imports = imports
return nil
}
} | go | func ImportsOption(imports *Imports) option {
return func(c *sass) error {
c.ctx.Imports = imports
return nil
}
} | [
"func",
"ImportsOption",
"(",
"imports",
"*",
"Imports",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"Imports",
"=",
"imports",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ImportsOption specifies configuration for import resolution | [
"ImportsOption",
"specifies",
"configuration",
"for",
"import",
"resolution"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L92-L97 |
15,621 | wellington/go-libsass | options.go | IncludePaths | func IncludePaths(includes []string) option {
return func(c *sass) error {
c.includePaths = includes
c.ctx.IncludePaths = includes
return nil
}
} | go | func IncludePaths(includes []string) option {
return func(c *sass) error {
c.includePaths = includes
c.ctx.IncludePaths = includes
return nil
}
} | [
"func",
"IncludePaths",
"(",
"includes",
"[",
"]",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"includePaths",
"=",
"includes",
"\n",
"c",
".",
"ctx",
".",
"IncludePaths",
"=",
"includes",
"\n",
... | // IncludePaths adds additional directories to search for Sass files | [
"IncludePaths",
"adds",
"additional",
"directories",
"to",
"search",
"for",
"Sass",
"files"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L100-L106 |
15,622 | wellington/go-libsass | options.go | LineComments | func LineComments(b bool) option {
return func(c *sass) error {
c.cmt = b
return nil
}
} | go | func LineComments(b bool) option {
return func(c *sass) error {
c.cmt = b
return nil
}
} | [
"func",
"LineComments",
"(",
"b",
"bool",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"cmt",
"=",
"b",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // LineComments removes the line by line playby of the Sass compiler | [
"LineComments",
"removes",
"the",
"line",
"by",
"line",
"playby",
"of",
"the",
"Sass",
"compiler"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L109-L114 |
15,623 | wellington/go-libsass | options.go | Precision | func Precision(prec int) option {
return func(c *sass) error {
c.ctx.Precision = prec
return nil
}
} | go | func Precision(prec int) option {
return func(c *sass) error {
c.ctx.Precision = prec
return nil
}
} | [
"func",
"Precision",
"(",
"prec",
"int",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"Precision",
"=",
"prec",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Precision specifies the number of points beyond the decimal
// place is preserved during math calculations. | [
"Precision",
"specifies",
"the",
"number",
"of",
"points",
"beyond",
"the",
"decimal",
"place",
"is",
"preserved",
"during",
"math",
"calculations",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L127-L132 |
15,624 | wellington/go-libsass | options.go | SourceMap | func SourceMap(b bool, path, sourceMapRoot string) option {
return func(c *sass) error {
c.ctx.includeMap = b
c.mappath = path
if len(sourceMapRoot) > 0 {
c.sourceMapRoot = sourceMapRoot
}
return nil
}
} | go | func SourceMap(b bool, path, sourceMapRoot string) option {
return func(c *sass) error {
c.ctx.includeMap = b
c.mappath = path
if len(sourceMapRoot) > 0 {
c.sourceMapRoot = sourceMapRoot
}
return nil
}
} | [
"func",
"SourceMap",
"(",
"b",
"bool",
",",
"path",
",",
"sourceMapRoot",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"includeMap",
"=",
"b",
"\n",
"c",
".",
"mappath",
"=",
"path"... | // SourceMap behaves differently depending on compiler used. For
// compile, it will embed sourcemap into the source. For file
// compile, it will include a separate file with the source map. | [
"SourceMap",
"behaves",
"differently",
"depending",
"on",
"compiler",
"used",
".",
"For",
"compile",
"it",
"will",
"embed",
"sourcemap",
"into",
"the",
"source",
".",
"For",
"file",
"compile",
"it",
"will",
"include",
"a",
"separate",
"file",
"with",
"the",
... | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L137-L146 |
15,625 | wellington/go-libsass | options.go | Path | func Path(path string) option {
return func(c *sass) error {
c.srcFile = path
c.ctx.MainFile = path
return nil
}
} | go | func Path(path string) option {
return func(c *sass) error {
c.srcFile = path
c.ctx.MainFile = path
return nil
}
} | [
"func",
"Path",
"(",
"path",
"string",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"srcFile",
"=",
"path",
"\n",
"c",
".",
"ctx",
".",
"MainFile",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
... | // Path specifies a file to read instead of using the provided
// io.Reader. This activates file compiling that includes line numbers
// in the resulting output. | [
"Path",
"specifies",
"a",
"file",
"to",
"read",
"instead",
"of",
"using",
"the",
"provided",
"io",
".",
"Reader",
".",
"This",
"activates",
"file",
"compiling",
"that",
"includes",
"line",
"numbers",
"in",
"the",
"resulting",
"output",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L151-L157 |
15,626 | wellington/go-libsass | options.go | Payload | func Payload(load context.Context) option {
return func(c *sass) error {
c.ctx.Payload = load
return nil
}
} | go | func Payload(load context.Context) option {
return func(c *sass) error {
c.ctx.Payload = load
return nil
}
} | [
"func",
"Payload",
"(",
"load",
"context",
".",
"Context",
")",
"option",
"{",
"return",
"func",
"(",
"c",
"*",
"sass",
")",
"error",
"{",
"c",
".",
"ctx",
".",
"Payload",
"=",
"load",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Payload gives access to sprite and image information for handlers
// to perform spriting functions. | [
"Payload",
"gives",
"access",
"to",
"sprite",
"and",
"image",
"information",
"for",
"handlers",
"to",
"perform",
"spriting",
"functions",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/options.go#L161-L166 |
15,627 | wellington/go-libsass | libs/safemap.go | Set | func (s *SafeMap) Set(ie interface{}) int {
idx := s.nextidx()
s.Lock()
s.m[idx] = ie
defer s.Unlock()
return idx
} | go | func (s *SafeMap) Set(ie interface{}) int {
idx := s.nextidx()
s.Lock()
s.m[idx] = ie
defer s.Unlock()
return idx
} | [
"func",
"(",
"s",
"*",
"SafeMap",
")",
"Set",
"(",
"ie",
"interface",
"{",
"}",
")",
"int",
"{",
"idx",
":=",
"s",
".",
"nextidx",
"(",
")",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"s",
".",
"m",
"[",
"idx",
"]",
"=",
"ie",
"\n",
"defer",
... | // set accepts an entry and returns an index for it | [
"set",
"accepts",
"an",
"entry",
"and",
"returns",
"an",
"index",
"for",
"it"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/safemap.go#L37-L44 |
15,628 | wellington/go-libsass | importer.go | Add | func (p *Imports) Add(prev string, path string, bs []byte) error {
p.Lock()
defer p.Unlock()
// TODO: align these with libsass name "stdin"
if len(prev) == 0 || prev == "string" {
prev = "stdin"
}
im := Import{
bytes: bs,
mod: time.Now(),
Prev: prev,
Path: path,
}
p.m[prev+":"+path] = im
return nil
} | go | func (p *Imports) Add(prev string, path string, bs []byte) error {
p.Lock()
defer p.Unlock()
// TODO: align these with libsass name "stdin"
if len(prev) == 0 || prev == "string" {
prev = "stdin"
}
im := Import{
bytes: bs,
mod: time.Now(),
Prev: prev,
Path: path,
}
p.m[prev+":"+path] = im
return nil
} | [
"func",
"(",
"p",
"*",
"Imports",
")",
"Add",
"(",
"prev",
"string",
",",
"path",
"string",
",",
"bs",
"[",
"]",
"byte",
")",
"error",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"// TODO: align these with ... | // Add registers an import in the context.Imports | [
"Add",
"registers",
"an",
"import",
"in",
"the",
"context",
".",
"Imports"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/importer.go#L65-L82 |
15,629 | wellington/go-libsass | importer.go | Del | func (p *Imports) Del(path string) {
p.Lock()
defer p.Unlock()
delete(p.m, path)
} | go | func (p *Imports) Del(path string) {
p.Lock()
defer p.Unlock()
delete(p.m, path)
} | [
"func",
"(",
"p",
"*",
"Imports",
")",
"Del",
"(",
"path",
"string",
")",
"{",
"p",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"p",
".",
"m",
",",
"path",
")",
"\n",
"}"
] | // Del removes the import from the context.Imports | [
"Del",
"removes",
"the",
"import",
"from",
"the",
"context",
".",
"Imports"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/importer.go#L85-L90 |
15,630 | wellington/go-libsass | importer.go | Get | func (p *Imports) Get(prev, path string) ([]byte, error) {
p.RLock()
defer p.RUnlock()
for _, imp := range p.m {
if imp.Prev == prev && imp.Path == path {
return imp.bytes, nil
}
}
return nil, ErrImportNotFound
} | go | func (p *Imports) Get(prev, path string) ([]byte, error) {
p.RLock()
defer p.RUnlock()
for _, imp := range p.m {
if imp.Prev == prev && imp.Path == path {
return imp.bytes, nil
}
}
return nil, ErrImportNotFound
} | [
"func",
"(",
"p",
"*",
"Imports",
")",
"Get",
"(",
"prev",
",",
"path",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"p",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"imp",
"... | // Get retrieves import bytes by path | [
"Get",
"retrieves",
"import",
"bytes",
"by",
"path"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/importer.go#L93-L102 |
15,631 | wellington/go-libsass | importer.go | Bind | func (p *Imports) Bind(opts libs.SassOptions) {
entries := make([]libs.ImportEntry, p.Len())
i := 0
p.RLock()
for _, ent := range p.m {
bs := ent.bytes
entries[i] = libs.ImportEntry{
Parent: ent.Prev,
Path: ent.Path,
Source: string(bs),
}
i++
}
p.RUnlock()
resolver := func(url string, prev string) (newURL string, body string, resolved bool) {
if p.resolver != nil {
newURL, body, resolved = p.resolver(url, prev)
if resolved {
return
}
}
entry, err := libs.GetEntry(entries, prev, url)
if err == nil {
return url, entry, true
}
return "", "", false
}
// set entries somewhere so GC doesn't collect it
p.idx = libs.BindImporter(opts, resolver)
} | go | func (p *Imports) Bind(opts libs.SassOptions) {
entries := make([]libs.ImportEntry, p.Len())
i := 0
p.RLock()
for _, ent := range p.m {
bs := ent.bytes
entries[i] = libs.ImportEntry{
Parent: ent.Prev,
Path: ent.Path,
Source: string(bs),
}
i++
}
p.RUnlock()
resolver := func(url string, prev string) (newURL string, body string, resolved bool) {
if p.resolver != nil {
newURL, body, resolved = p.resolver(url, prev)
if resolved {
return
}
}
entry, err := libs.GetEntry(entries, prev, url)
if err == nil {
return url, entry, true
}
return "", "", false
}
// set entries somewhere so GC doesn't collect it
p.idx = libs.BindImporter(opts, resolver)
} | [
"func",
"(",
"p",
"*",
"Imports",
")",
"Bind",
"(",
"opts",
"libs",
".",
"SassOptions",
")",
"{",
"entries",
":=",
"make",
"(",
"[",
"]",
"libs",
".",
"ImportEntry",
",",
"p",
".",
"Len",
"(",
")",
")",
"\n",
"i",
":=",
"0",
"\n\n",
"p",
".",
... | // Bind accepts a SassOptions and adds the registered
// importers in the context. | [
"Bind",
"accepts",
"a",
"SassOptions",
"and",
"adds",
"the",
"registered",
"importers",
"in",
"the",
"context",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/importer.go#L119-L151 |
15,632 | wellington/go-libsass | libs/encoding.go | MakeError | func MakeError(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_error(cs)
} | go | func MakeError(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_error(cs)
} | [
"func",
"MakeError",
"(",
"s",
"string",
")",
"UnionSassValue",
"{",
"cs",
":=",
"C",
".",
"CString",
"(",
"s",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cs",
")",
")",
"\n",
"return",
"C",
".",
"sass_make_error",
"... | // MakeError creates Sass error from a string | [
"MakeError",
"creates",
"Sass",
"error",
"from",
"a",
"string"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L38-L42 |
15,633 | wellington/go-libsass | libs/encoding.go | MakeWarning | func MakeWarning(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_warning(cs)
} | go | func MakeWarning(s string) UnionSassValue {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
return C.sass_make_warning(cs)
} | [
"func",
"MakeWarning",
"(",
"s",
"string",
")",
"UnionSassValue",
"{",
"cs",
":=",
"C",
".",
"CString",
"(",
"s",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cs",
")",
")",
"\n",
"return",
"C",
".",
"sass_make_warning",... | // MakeWarning creates Sass warning from a string | [
"MakeWarning",
"creates",
"Sass",
"warning",
"from",
"a",
"string"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L45-L49 |
15,634 | wellington/go-libsass | libs/encoding.go | MakeColor | func MakeColor(c color.RGBA) UnionSassValue {
r := C.double(c.R)
g := C.double(c.G)
b := C.double(c.B)
a := C.double(c.A)
return C.sass_make_color(r, g, b, a)
} | go | func MakeColor(c color.RGBA) UnionSassValue {
r := C.double(c.R)
g := C.double(c.G)
b := C.double(c.B)
a := C.double(c.A)
return C.sass_make_color(r, g, b, a)
} | [
"func",
"MakeColor",
"(",
"c",
"color",
".",
"RGBA",
")",
"UnionSassValue",
"{",
"r",
":=",
"C",
".",
"double",
"(",
"c",
".",
"R",
")",
"\n",
"g",
":=",
"C",
".",
"double",
"(",
"c",
".",
"G",
")",
"\n",
"b",
":=",
"C",
".",
"double",
"(",
... | // MakeColor creates a Sass color from color.RGBA | [
"MakeColor",
"creates",
"a",
"Sass",
"color",
"from",
"color",
".",
"RGBA"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L66-L72 |
15,635 | wellington/go-libsass | libs/encoding.go | MakeList | func MakeList(len int) UnionSassValue {
return C.sass_make_list(C.size_t(len), C.SASS_COMMA, false)
} | go | func MakeList(len int) UnionSassValue {
return C.sass_make_list(C.size_t(len), C.SASS_COMMA, false)
} | [
"func",
"MakeList",
"(",
"len",
"int",
")",
"UnionSassValue",
"{",
"return",
"C",
".",
"sass_make_list",
"(",
"C",
".",
"size_t",
"(",
"len",
")",
",",
"C",
".",
"SASS_COMMA",
",",
"false",
")",
"\n",
"}"
] | // MakeList creates a Sass List | [
"MakeList",
"creates",
"a",
"Sass",
"List"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L75-L77 |
15,636 | wellington/go-libsass | libs/encoding.go | Slice | func Slice(usv UnionSassValue, inf interface{}) {
if !IsList(usv) {
panic("sass value is not a list")
}
l := Len(usv)
r := reflect.ValueOf(inf)
if r.Kind() == reflect.Ptr {
r = r.Elem()
}
if !r.CanSet() {
panic("value is not addressable")
}
// if a non-slice is passed, make a slice
t := r.Type()
if r.Kind() != reflect.Slice {
t = reflect.SliceOf(t)
}
d := reflect.MakeSlice(t, l, l)
for i := 0; i < l; i++ {
sv := Index(usv, i)
inf := Interface(sv)
rf := reflect.ValueOf(inf)
// Special case for nil
if inf == nil {
d.Index(i).Set(reflect.ValueOf("<nil>"))
continue
}
d.Index(i).Set(rf)
}
r.Set(d)
} | go | func Slice(usv UnionSassValue, inf interface{}) {
if !IsList(usv) {
panic("sass value is not a list")
}
l := Len(usv)
r := reflect.ValueOf(inf)
if r.Kind() == reflect.Ptr {
r = r.Elem()
}
if !r.CanSet() {
panic("value is not addressable")
}
// if a non-slice is passed, make a slice
t := r.Type()
if r.Kind() != reflect.Slice {
t = reflect.SliceOf(t)
}
d := reflect.MakeSlice(t, l, l)
for i := 0; i < l; i++ {
sv := Index(usv, i)
inf := Interface(sv)
rf := reflect.ValueOf(inf)
// Special case for nil
if inf == nil {
d.Index(i).Set(reflect.ValueOf("<nil>"))
continue
}
d.Index(i).Set(rf)
}
r.Set(d)
} | [
"func",
"Slice",
"(",
"usv",
"UnionSassValue",
",",
"inf",
"interface",
"{",
"}",
")",
"{",
"if",
"!",
"IsList",
"(",
"usv",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"l",
":=",
"Len",
"(",
"usv",
")",
"\n",
"r",
":=",
"reflect"... | // Slice creates a Sass List from a Go slice. Reflection is used. | [
"Slice",
"creates",
"a",
"Sass",
"List",
"from",
"a",
"Go",
"slice",
".",
"Reflection",
"is",
"used",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L85-L115 |
15,637 | wellington/go-libsass | libs/encoding.go | Interface | func Interface(usv UnionSassValue) interface{} {
switch {
case IsNil(usv):
return nil
case IsBool(usv):
return Bool(usv)
case IsString(usv):
return String(usv)
case IsColor(usv):
return Color(usv)
case IsNumber(usv):
return Number(usv)
case IsList(usv):
fallthrough
//return List(usv)
case IsMap(usv):
fallthrough
//return Map(usv)
default:
return nil
}
panic("call of interface not supported on type")
} | go | func Interface(usv UnionSassValue) interface{} {
switch {
case IsNil(usv):
return nil
case IsBool(usv):
return Bool(usv)
case IsString(usv):
return String(usv)
case IsColor(usv):
return Color(usv)
case IsNumber(usv):
return Number(usv)
case IsList(usv):
fallthrough
//return List(usv)
case IsMap(usv):
fallthrough
//return Map(usv)
default:
return nil
}
panic("call of interface not supported on type")
} | [
"func",
"Interface",
"(",
"usv",
"UnionSassValue",
")",
"interface",
"{",
"}",
"{",
"switch",
"{",
"case",
"IsNil",
"(",
"usv",
")",
":",
"return",
"nil",
"\n",
"case",
"IsBool",
"(",
"usv",
")",
":",
"return",
"Bool",
"(",
"usv",
")",
"\n",
"case",
... | // Interface creates Go types from union sass_value | [
"Interface",
"creates",
"Go",
"types",
"from",
"union",
"sass_value"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/encoding.go#L150-L172 |
15,638 | wellington/go-libsass | toscss.go | ToScss | func ToScss(r io.Reader, w io.Writer) error {
return libs.ToScss(r, w)
} | go | func ToScss(r io.Reader, w io.Writer) error {
return libs.ToScss(r, w)
} | [
"func",
"ToScss",
"(",
"r",
"io",
".",
"Reader",
",",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"return",
"libs",
".",
"ToScss",
"(",
"r",
",",
"w",
")",
"\n",
"}"
] | // ToScss converts Sass to Scss with libsass sass2scss.h | [
"ToScss",
"converts",
"Sass",
"to",
"Scss",
"with",
"libsass",
"sass2scss",
".",
"h"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/toscss.go#L10-L12 |
15,639 | wellington/go-libsass | libs/func.go | SassMakeFunction | func SassMakeFunction(signature string, idx int) SassFunc {
csign := C.CString(signature)
ptr := unsafe.Pointer(uintptr(idx))
fn := C.sass_make_function(
csign,
C.Sass_Function_Fn(C.CallSassFunction),
ptr)
return (SassFunc)(fn)
} | go | func SassMakeFunction(signature string, idx int) SassFunc {
csign := C.CString(signature)
ptr := unsafe.Pointer(uintptr(idx))
fn := C.sass_make_function(
csign,
C.Sass_Function_Fn(C.CallSassFunction),
ptr)
return (SassFunc)(fn)
} | [
"func",
"SassMakeFunction",
"(",
"signature",
"string",
",",
"idx",
"int",
")",
"SassFunc",
"{",
"csign",
":=",
"C",
".",
"CString",
"(",
"signature",
")",
"\n",
"ptr",
":=",
"unsafe",
".",
"Pointer",
"(",
"uintptr",
"(",
"idx",
")",
")",
"\n",
"fn",
... | // SassMakeFunction binds a Go pointer to a Sass function signature | [
"SassMakeFunction",
"binds",
"a",
"Go",
"pointer",
"to",
"a",
"Sass",
"function",
"signature"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/func.go#L23-L32 |
15,640 | wellington/go-libsass | libs/func.go | BindFuncs | func BindFuncs(opts SassOptions, cookies []Cookie) []int {
funcs := make([]SassFunc, len(cookies))
ids := make([]int, len(cookies))
for i, cookie := range cookies {
idx := globalFuncs.Set(cookies[i])
fn := SassMakeFunction(cookie.Sign, idx)
funcs[i] = fn
ids[i] = idx
}
sz := C.size_t(len(funcs))
cfuncs := C.sass_make_function_list(sz)
for i, cfn := range funcs {
C.sass_function_set_list_entry(cfuncs, C.size_t(i), C.Sass_Function_Entry(cfn))
}
C.sass_option_set_c_functions(opts, cfuncs)
return ids
} | go | func BindFuncs(opts SassOptions, cookies []Cookie) []int {
funcs := make([]SassFunc, len(cookies))
ids := make([]int, len(cookies))
for i, cookie := range cookies {
idx := globalFuncs.Set(cookies[i])
fn := SassMakeFunction(cookie.Sign, idx)
funcs[i] = fn
ids[i] = idx
}
sz := C.size_t(len(funcs))
cfuncs := C.sass_make_function_list(sz)
for i, cfn := range funcs {
C.sass_function_set_list_entry(cfuncs, C.size_t(i), C.Sass_Function_Entry(cfn))
}
C.sass_option_set_c_functions(opts, cfuncs)
return ids
} | [
"func",
"BindFuncs",
"(",
"opts",
"SassOptions",
",",
"cookies",
"[",
"]",
"Cookie",
")",
"[",
"]",
"int",
"{",
"funcs",
":=",
"make",
"(",
"[",
"]",
"SassFunc",
",",
"len",
"(",
"cookies",
")",
")",
"\n",
"ids",
":=",
"make",
"(",
"[",
"]",
"int... | // BindFuncs attaches a slice of Functions to a sass options. Signatures
// are already defined in the SassFunc. | [
"BindFuncs",
"attaches",
"a",
"slice",
"of",
"Functions",
"to",
"a",
"sass",
"options",
".",
"Signatures",
"are",
"already",
"defined",
"in",
"the",
"SassFunc",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/func.go#L42-L60 |
15,641 | wellington/go-libsass | func.go | RegisterSassFunc | func RegisterSassFunc(sign string, fn SassFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: SassHandler(fn),
})
ghMu.Unlock()
} | go | func RegisterSassFunc(sign string, fn SassFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: SassHandler(fn),
})
ghMu.Unlock()
} | [
"func",
"RegisterSassFunc",
"(",
"sign",
"string",
",",
"fn",
"SassFunc",
")",
"{",
"ghMu",
".",
"Lock",
"(",
")",
"\n",
"globalHandlers",
"=",
"append",
"(",
"globalHandlers",
",",
"handler",
"{",
"sign",
":",
"sign",
",",
"callback",
":",
"SassHandler",
... | // RegisterSassFunc assigns the passed Func to the specified signature sign | [
"RegisterSassFunc",
"assigns",
"the",
"passed",
"Func",
"to",
"the",
"specified",
"signature",
"sign"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L19-L26 |
15,642 | wellington/go-libsass | func.go | CompFromCtx | func CompFromCtx(ctx context.Context) (Compiler, error) {
v := ctx.Value(compkey)
comp, ok := v.(Compiler)
if !ok {
return comp, ErrCompilerNotFound
}
return comp, nil
} | go | func CompFromCtx(ctx context.Context) (Compiler, error) {
v := ctx.Value(compkey)
comp, ok := v.(Compiler)
if !ok {
return comp, ErrCompilerNotFound
}
return comp, nil
} | [
"func",
"CompFromCtx",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"Compiler",
",",
"error",
")",
"{",
"v",
":=",
"ctx",
".",
"Value",
"(",
"compkey",
")",
"\n",
"comp",
",",
"ok",
":=",
"v",
".",
"(",
"Compiler",
")",
"\n",
"if",
"!",
"ok",... | // CompFromCtx retrieves a compiler from a passed context | [
"CompFromCtx",
"retrieves",
"a",
"compiler",
"from",
"a",
"passed",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L41-L48 |
15,643 | wellington/go-libsass | func.go | SassHandler | func SassHandler(h SassFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
libCtx, ok := v.(*compctx)
if !ok {
return errors.New("libsass Context not found")
}
ctx := NewCompilerContext(libCtx.compiler)
// Cast to exported Go types
req := SassValue{value: usv}
res, err := h(ctx, req)
if err != nil {
// Returns the error to libsass Compiler
*rsv = libs.MakeError(err.Error())
// Returning an error does nothing as libsass is in charge of
// reporting error to user
return err
}
*rsv = res.Val()
return err
}
} | go | func SassHandler(h SassFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
libCtx, ok := v.(*compctx)
if !ok {
return errors.New("libsass Context not found")
}
ctx := NewCompilerContext(libCtx.compiler)
// Cast to exported Go types
req := SassValue{value: usv}
res, err := h(ctx, req)
if err != nil {
// Returns the error to libsass Compiler
*rsv = libs.MakeError(err.Error())
// Returning an error does nothing as libsass is in charge of
// reporting error to user
return err
}
*rsv = res.Val()
return err
}
} | [
"func",
"SassHandler",
"(",
"h",
"SassFunc",
")",
"libs",
".",
"SassCallback",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
",",
"usv",
"libs",
".",
"UnionSassValue",
",",
"rsv",
"*",
"libs",
".",
"UnionSassValue",
")",
"error",
"{",
"if",
"... | // SassHandler contains callback context for running code within
// a libsass handler | [
"SassHandler",
"contains",
"callback",
"context",
"for",
"running",
"code",
"within",
"a",
"libsass",
"handler"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L55-L83 |
15,644 | wellington/go-libsass | func.go | RegisterHandler | func RegisterHandler(sign string, callback HandlerFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: Handler(callback),
})
ghMu.Unlock()
} | go | func RegisterHandler(sign string, callback HandlerFunc) {
ghMu.Lock()
globalHandlers = append(globalHandlers, handler{
sign: sign,
callback: Handler(callback),
})
ghMu.Unlock()
} | [
"func",
"RegisterHandler",
"(",
"sign",
"string",
",",
"callback",
"HandlerFunc",
")",
"{",
"ghMu",
".",
"Lock",
"(",
")",
"\n",
"globalHandlers",
"=",
"append",
"(",
"globalHandlers",
",",
"handler",
"{",
"sign",
":",
"sign",
",",
"callback",
":",
"Handle... | // RegisterHandler sets the passed signature and callback to the
// handlers array. | [
"RegisterHandler",
"sets",
"the",
"passed",
"signature",
"and",
"callback",
"to",
"the",
"handlers",
"array",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L87-L94 |
15,645 | wellington/go-libsass | func.go | Handler | func Handler(h HandlerFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
req := SassValue{value: usv}
res := SassValue{value: *rsv}
err := h(v, req, &res)
if rsv != nil {
*rsv = res.Val()
}
return err
}
} | go | func Handler(h HandlerFunc) libs.SassCallback {
return func(v interface{}, usv libs.UnionSassValue, rsv *libs.UnionSassValue) error {
if *rsv == nil {
*rsv = libs.MakeNil()
}
req := SassValue{value: usv}
res := SassValue{value: *rsv}
err := h(v, req, &res)
if rsv != nil {
*rsv = res.Val()
}
return err
}
} | [
"func",
"Handler",
"(",
"h",
"HandlerFunc",
")",
"libs",
".",
"SassCallback",
"{",
"return",
"func",
"(",
"v",
"interface",
"{",
"}",
",",
"usv",
"libs",
".",
"UnionSassValue",
",",
"rsv",
"*",
"libs",
".",
"UnionSassValue",
")",
"error",
"{",
"if",
"*... | // Handler accepts a HandlerFunc and returns SassCallback for sending
// to libsass. The third argument must be a pointer and the function
// must return an error. | [
"Handler",
"accepts",
"a",
"HandlerFunc",
"and",
"returns",
"SassCallback",
"for",
"sending",
"to",
"libsass",
".",
"The",
"third",
"argument",
"must",
"be",
"a",
"pointer",
"and",
"the",
"function",
"must",
"return",
"an",
"error",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L103-L118 |
15,646 | wellington/go-libsass | func.go | Bind | func (fs *Funcs) Bind(goopts libs.SassOptions) {
ghMu.RLock()
cookies := make([]libs.Cookie, len(globalHandlers)+len(fs.f))
// Append registered handlers to cookie array
for i, h := range globalHandlers {
cookies[i] = libs.Cookie{
Sign: h.sign,
Fn: h.callback,
Ctx: fs.ctx,
}
}
l := len(globalHandlers)
ghMu.RUnlock()
for i, h := range fs.f {
cookies[i+l] = libs.Cookie{
Sign: h.Sign,
Fn: h.Fn,
Ctx: fs.ctx,
}
}
fs.idx = libs.BindFuncs(goopts, cookies)
} | go | func (fs *Funcs) Bind(goopts libs.SassOptions) {
ghMu.RLock()
cookies := make([]libs.Cookie, len(globalHandlers)+len(fs.f))
// Append registered handlers to cookie array
for i, h := range globalHandlers {
cookies[i] = libs.Cookie{
Sign: h.sign,
Fn: h.callback,
Ctx: fs.ctx,
}
}
l := len(globalHandlers)
ghMu.RUnlock()
for i, h := range fs.f {
cookies[i+l] = libs.Cookie{
Sign: h.Sign,
Fn: h.Fn,
Ctx: fs.ctx,
}
}
fs.idx = libs.BindFuncs(goopts, cookies)
} | [
"func",
"(",
"fs",
"*",
"Funcs",
")",
"Bind",
"(",
"goopts",
"libs",
".",
"SassOptions",
")",
"{",
"ghMu",
".",
"RLock",
"(",
")",
"\n",
"cookies",
":=",
"make",
"(",
"[",
"]",
"libs",
".",
"Cookie",
",",
"len",
"(",
"globalHandlers",
")",
"+",
"... | // SetFunc assigns the registered methods to SassOptions. Functions
// are called when the compiler encounters the registered signature. | [
"SetFunc",
"assigns",
"the",
"registered",
"methods",
"to",
"SassOptions",
".",
"Functions",
"are",
"called",
"when",
"the",
"compiler",
"encounters",
"the",
"registered",
"signature",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/func.go#L175-L197 |
15,647 | wellington/go-libsass | context.go | Init | func (ctx *compctx) Init(goopts libs.SassOptions) libs.SassOptions {
if ctx.Precision == 0 {
ctx.Precision = 5
}
ctx.options = goopts
ctx.Headers.Bind(goopts)
ctx.Imports.Bind(goopts)
ctx.Funcs.Bind(goopts)
libs.SassOptionSetSourceComments(goopts, ctx.compiler.LineComments())
//os.PathListSeparator
incs := strings.Join(ctx.IncludePaths, string(os.PathListSeparator))
libs.SassOptionSetIncludePath(goopts, incs)
libs.SassOptionSetPrecision(goopts, ctx.Precision)
libs.SassOptionSetOutputStyle(goopts, ctx.OutputStyle)
libs.SassOptionSetSourceComments(goopts, ctx.Comments)
if ctx.includeMap {
libs.SassOptionSetSourceMapEmbed(goopts, true)
}
return goopts
} | go | func (ctx *compctx) Init(goopts libs.SassOptions) libs.SassOptions {
if ctx.Precision == 0 {
ctx.Precision = 5
}
ctx.options = goopts
ctx.Headers.Bind(goopts)
ctx.Imports.Bind(goopts)
ctx.Funcs.Bind(goopts)
libs.SassOptionSetSourceComments(goopts, ctx.compiler.LineComments())
//os.PathListSeparator
incs := strings.Join(ctx.IncludePaths, string(os.PathListSeparator))
libs.SassOptionSetIncludePath(goopts, incs)
libs.SassOptionSetPrecision(goopts, ctx.Precision)
libs.SassOptionSetOutputStyle(goopts, ctx.OutputStyle)
libs.SassOptionSetSourceComments(goopts, ctx.Comments)
if ctx.includeMap {
libs.SassOptionSetSourceMapEmbed(goopts, true)
}
return goopts
} | [
"func",
"(",
"ctx",
"*",
"compctx",
")",
"Init",
"(",
"goopts",
"libs",
".",
"SassOptions",
")",
"libs",
".",
"SassOptions",
"{",
"if",
"ctx",
".",
"Precision",
"==",
"0",
"{",
"ctx",
".",
"Precision",
"=",
"5",
"\n",
"}",
"\n",
"ctx",
".",
"option... | // Init validates options in the struct and returns a Sass Options. | [
"Init",
"validates",
"options",
"in",
"the",
"struct",
"and",
"returns",
"a",
"Sass",
"Options",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/context.go#L105-L126 |
15,648 | wellington/go-libsass | context.go | compile | func (ctx *compctx) compile(out io.Writer, in io.Reader) error {
defer ctx.Reset()
var (
bs []byte
err error
)
// libSass will fail on Sass syntax given as non-file input
// convert the input on its behalf
if ctx.compiler.Syntax() == SassSyntax {
// this is memory intensive
var buf bytes.Buffer
err := ToScss(in, &buf)
if err != nil {
return err
}
bs = buf.Bytes()
} else {
// ScssSyntax
bs, err = ioutil.ReadAll(in)
if err != nil {
return err
}
}
if len(bs) == 0 {
return errors.New("No input provided")
}
godc := libs.SassMakeDataContext(string(bs))
goopts := libs.SassDataContextGetOptions(godc)
libs.SassOptionSetSourceComments(goopts, true)
ctx.Init(goopts)
libs.SassDataContextSetOptions(godc, goopts)
goctx := libs.SassDataContextGetContext(godc)
ctx.context = goctx
gocompiler := libs.SassMakeDataCompiler(godc)
libs.SassCompilerParse(gocompiler)
libs.SassCompilerExecute(gocompiler)
defer libs.SassDeleteCompiler(gocompiler)
goout := libs.SassContextGetOutputString(goctx)
io.WriteString(out, goout)
ctx.Status = libs.SassContextGetErrorStatus(goctx)
errJSON := libs.SassContextGetErrorJSON(goctx)
err = ctx.ProcessSassError([]byte(errJSON))
if err != nil {
return err
}
if ctx.Error() != "" {
lines := bytes.Split(bs, []byte("\n"))
var out string
for i := -7; i < 7; i++ {
if i+ctx.err.Line >= 0 && i+ctx.err.Line < len(lines) {
out += fmt.Sprintf("%s\n", string(lines[i+ctx.err.Line]))
}
}
// TODO: this is weird, make something more idiomatic
return errors.New(ctx.Error() + "\n" + out)
}
return nil
} | go | func (ctx *compctx) compile(out io.Writer, in io.Reader) error {
defer ctx.Reset()
var (
bs []byte
err error
)
// libSass will fail on Sass syntax given as non-file input
// convert the input on its behalf
if ctx.compiler.Syntax() == SassSyntax {
// this is memory intensive
var buf bytes.Buffer
err := ToScss(in, &buf)
if err != nil {
return err
}
bs = buf.Bytes()
} else {
// ScssSyntax
bs, err = ioutil.ReadAll(in)
if err != nil {
return err
}
}
if len(bs) == 0 {
return errors.New("No input provided")
}
godc := libs.SassMakeDataContext(string(bs))
goopts := libs.SassDataContextGetOptions(godc)
libs.SassOptionSetSourceComments(goopts, true)
ctx.Init(goopts)
libs.SassDataContextSetOptions(godc, goopts)
goctx := libs.SassDataContextGetContext(godc)
ctx.context = goctx
gocompiler := libs.SassMakeDataCompiler(godc)
libs.SassCompilerParse(gocompiler)
libs.SassCompilerExecute(gocompiler)
defer libs.SassDeleteCompiler(gocompiler)
goout := libs.SassContextGetOutputString(goctx)
io.WriteString(out, goout)
ctx.Status = libs.SassContextGetErrorStatus(goctx)
errJSON := libs.SassContextGetErrorJSON(goctx)
err = ctx.ProcessSassError([]byte(errJSON))
if err != nil {
return err
}
if ctx.Error() != "" {
lines := bytes.Split(bs, []byte("\n"))
var out string
for i := -7; i < 7; i++ {
if i+ctx.err.Line >= 0 && i+ctx.err.Line < len(lines) {
out += fmt.Sprintf("%s\n", string(lines[i+ctx.err.Line]))
}
}
// TODO: this is weird, make something more idiomatic
return errors.New(ctx.Error() + "\n" + out)
}
return nil
} | [
"func",
"(",
"ctx",
"*",
"compctx",
")",
"compile",
"(",
"out",
"io",
".",
"Writer",
",",
"in",
"io",
".",
"Reader",
")",
"error",
"{",
"defer",
"ctx",
".",
"Reset",
"(",
")",
"\n",
"var",
"(",
"bs",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n"... | // compile reads in and writes the libsass compiled result to out.
// Options and custom functions are applied as specified in Context. | [
"compile",
"reads",
"in",
"and",
"writes",
"the",
"libsass",
"compiled",
"result",
"to",
"out",
".",
"Options",
"and",
"custom",
"functions",
"are",
"applied",
"as",
"specified",
"in",
"Context",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/context.go#L201-L268 |
15,649 | wellington/go-libsass | context.go | RelativeImage | func (p *compctx) RelativeImage() string {
rel, _ := filepath.Rel(p.BuildDir, p.ImageDir)
return filepath.ToSlash(filepath.Clean(rel))
} | go | func (p *compctx) RelativeImage() string {
rel, _ := filepath.Rel(p.BuildDir, p.ImageDir)
return filepath.ToSlash(filepath.Clean(rel))
} | [
"func",
"(",
"p",
"*",
"compctx",
")",
"RelativeImage",
"(",
")",
"string",
"{",
"rel",
",",
"_",
":=",
"filepath",
".",
"Rel",
"(",
"p",
".",
"BuildDir",
",",
"p",
".",
"ImageDir",
")",
"\n",
"return",
"filepath",
".",
"ToSlash",
"(",
"filepath",
... | // Rel creates relative paths between the build directory where the CSS lives
// and the image directory that is being linked. This is not compatible
// with generated images like sprites. | [
"Rel",
"creates",
"relative",
"paths",
"between",
"the",
"build",
"directory",
"where",
"the",
"CSS",
"lives",
"and",
"the",
"image",
"directory",
"that",
"is",
"being",
"linked",
".",
"This",
"is",
"not",
"compatible",
"with",
"generated",
"images",
"like",
... | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/context.go#L273-L276 |
15,650 | wellington/go-libsass | export.go | Error | func Error(err error) SassValue {
return SassValue{value: libs.MakeError(err.Error())}
} | go | func Error(err error) SassValue {
return SassValue{value: libs.MakeError(err.Error())}
} | [
"func",
"Error",
"(",
"err",
"error",
")",
"SassValue",
"{",
"return",
"SassValue",
"{",
"value",
":",
"libs",
".",
"MakeError",
"(",
"err",
".",
"Error",
"(",
")",
")",
"}",
"\n",
"}"
] | // Error takes a Go error and returns a libsass Error | [
"Error",
"takes",
"a",
"Go",
"error",
"and",
"returns",
"a",
"libsass",
"Error"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/export.go#L6-L8 |
15,651 | wellington/go-libsass | libs/export.go | GoBridge | func GoBridge(cargs UnionSassValue, cidx C.int) UnionSassValue {
// Recover the Cookie struct passed in
idx := int(cidx)
ck, ok := globalFuncs.Get(idx).(Cookie)
if !ok {
fmt.Printf("failed to resolve Cookie %d\n", idx)
return MakeNil()
}
// ck := *(*Cookie)(ptr)
var usv UnionSassValue
err := ck.Fn(ck.Ctx, cargs, &usv)
_ = err
return usv
} | go | func GoBridge(cargs UnionSassValue, cidx C.int) UnionSassValue {
// Recover the Cookie struct passed in
idx := int(cidx)
ck, ok := globalFuncs.Get(idx).(Cookie)
if !ok {
fmt.Printf("failed to resolve Cookie %d\n", idx)
return MakeNil()
}
// ck := *(*Cookie)(ptr)
var usv UnionSassValue
err := ck.Fn(ck.Ctx, cargs, &usv)
_ = err
return usv
} | [
"func",
"GoBridge",
"(",
"cargs",
"UnionSassValue",
",",
"cidx",
"C",
".",
"int",
")",
"UnionSassValue",
"{",
"// Recover the Cookie struct passed in",
"idx",
":=",
"int",
"(",
"cidx",
")",
"\n",
"ck",
",",
"ok",
":=",
"globalFuncs",
".",
"Get",
"(",
"idx",
... | // GoBridge is exported to C for linking libsass to Go. This function
// adheres to the interface provided by libsass.
//
//export GoBridge | [
"GoBridge",
"is",
"exported",
"to",
"C",
"for",
"linking",
"libsass",
"to",
"Go",
".",
"This",
"function",
"adheres",
"to",
"the",
"interface",
"provided",
"by",
"libsass",
".",
"export",
"GoBridge"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/export.go#L31-L45 |
15,652 | wellington/go-libsass | libs/header.go | BindHeader | func BindHeader(opts SassOptions, entries []ImportEntry) int {
idx := globalHeaders.Set(entries)
// ptr := unsafe.Pointer(idx)
czero := C.double(0)
imper := C.sass_make_importer(
C.Sass_Importer_Fn(C.SassHeaders),
czero,
unsafe.Pointer(uintptr(idx)),
)
impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_headers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers)
return idx
} | go | func BindHeader(opts SassOptions, entries []ImportEntry) int {
idx := globalHeaders.Set(entries)
// ptr := unsafe.Pointer(idx)
czero := C.double(0)
imper := C.sass_make_importer(
C.Sass_Importer_Fn(C.SassHeaders),
czero,
unsafe.Pointer(uintptr(idx)),
)
impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_headers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers)
return idx
} | [
"func",
"BindHeader",
"(",
"opts",
"SassOptions",
",",
"entries",
"[",
"]",
"ImportEntry",
")",
"int",
"{",
"idx",
":=",
"globalHeaders",
".",
"Set",
"(",
"entries",
")",
"\n",
"// ptr := unsafe.Pointer(idx)",
"czero",
":=",
"C",
".",
"double",
"(",
"0",
"... | // BindHeader attaches the header to a libsass context ensuring
// gc does not delete the pointers necessary to make this happen. | [
"BindHeader",
"attaches",
"the",
"header",
"to",
"a",
"libsass",
"context",
"ensuring",
"gc",
"does",
"not",
"delete",
"the",
"pointers",
"necessary",
"to",
"make",
"this",
"happen",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/header.go#L29-L46 |
15,653 | wellington/go-libsass | libs/sass_number.go | Add | func (sn SassNumber) Add(sn2 SassNumber) SassNumber {
sn1Value, sn2Value := getConvertedUnits(sn, sn2)
return SassNumber{Value: sn1Value + sn2Value, Unit: sn.Unit}
} | go | func (sn SassNumber) Add(sn2 SassNumber) SassNumber {
sn1Value, sn2Value := getConvertedUnits(sn, sn2)
return SassNumber{Value: sn1Value + sn2Value, Unit: sn.Unit}
} | [
"func",
"(",
"sn",
"SassNumber",
")",
"Add",
"(",
"sn2",
"SassNumber",
")",
"SassNumber",
"{",
"sn1Value",
",",
"sn2Value",
":=",
"getConvertedUnits",
"(",
"sn",
",",
"sn2",
")",
"\n",
"return",
"SassNumber",
"{",
"Value",
":",
"sn1Value",
"+",
"sn2Value",... | // Add sums the two numbers in the first numbers units | [
"Add",
"sums",
"the",
"two",
"numbers",
"in",
"the",
"first",
"numbers",
"units"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/sass_number.go#L151-L154 |
15,654 | wellington/go-libsass | libs/toscss.go | ToScss | func ToScss(r io.Reader, w io.Writer) error {
bs, _ := ioutil.ReadAll(r)
in := C.CString(string(bs))
defer C.free(unsafe.Pointer(in))
chars := C.sass2scss(
// FIXME: readers would be much more efficient
in,
// SASS2SCSS_PRETTIFY_1 Egyptian brackets
C.int(1),
)
_, err := io.WriteString(w, C.GoString(chars))
return err
} | go | func ToScss(r io.Reader, w io.Writer) error {
bs, _ := ioutil.ReadAll(r)
in := C.CString(string(bs))
defer C.free(unsafe.Pointer(in))
chars := C.sass2scss(
// FIXME: readers would be much more efficient
in,
// SASS2SCSS_PRETTIFY_1 Egyptian brackets
C.int(1),
)
_, err := io.WriteString(w, C.GoString(chars))
return err
} | [
"func",
"ToScss",
"(",
"r",
"io",
".",
"Reader",
",",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"bs",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"in",
":=",
"C",
".",
"CString",
"(",
"string",
"(",
"bs",
")",
")",
"\n",... | // ToScss converts Sass to Scss using sass2scss. Readers and Writers are
// used, but libsass does not support streaming. | [
"ToScss",
"converts",
"Sass",
"to",
"Scss",
"using",
"sass2scss",
".",
"Readers",
"and",
"Writers",
"are",
"used",
"but",
"libsass",
"does",
"not",
"support",
"streaming",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/toscss.go#L14-L27 |
15,655 | wellington/go-libsass | encoding.go | Unmarshal | func Unmarshal(arg SassValue, v ...interface{}) error {
var err error
sv := arg.Val()
var l int
if libs.IsList(sv) {
l = libs.Len(sv)
}
if arg.Val() == nil {
return errors.New("I can't work with this. arg UnionSassValue must not be nil. - Unmarshaller")
} else if len(v) == 0 {
return errors.New("Cannot Unmarshal an empty value - Michael Scott")
} else if len(v) > 1 {
if len(v) < l { //check for optional arguements that are not passed and pad with nil
return fmt.Errorf(
"Arguments mismatch %d C arguments did not match %d",
l, len(v))
}
for i := 0; i < l; i++ {
val := libs.Index(sv, i)
err = unmarshal(SassValue{value: val}, v[i])
if err != nil {
return err
}
}
return err
} else if libs.IsList(sv) &&
getKind(v[0]) != reflect.Slice &&
l == 1 { //arg is a slice of 1 but we want back a non slice
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
} else if libs.IsList(sv) &&
getKind(v[0]) == reflect.Slice &&
libs.IsList(libs.Index(sv, 0)) &&
l == 1 { //arg is a list of single list and we only want back a list so we need to unwrap
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
//return unmarshal(C.sass_list_get_value(arg, C.size_t(0)), v[0])
} else {
return unmarshal(arg, v[0])
}
} | go | func Unmarshal(arg SassValue, v ...interface{}) error {
var err error
sv := arg.Val()
var l int
if libs.IsList(sv) {
l = libs.Len(sv)
}
if arg.Val() == nil {
return errors.New("I can't work with this. arg UnionSassValue must not be nil. - Unmarshaller")
} else if len(v) == 0 {
return errors.New("Cannot Unmarshal an empty value - Michael Scott")
} else if len(v) > 1 {
if len(v) < l { //check for optional arguements that are not passed and pad with nil
return fmt.Errorf(
"Arguments mismatch %d C arguments did not match %d",
l, len(v))
}
for i := 0; i < l; i++ {
val := libs.Index(sv, i)
err = unmarshal(SassValue{value: val}, v[i])
if err != nil {
return err
}
}
return err
} else if libs.IsList(sv) &&
getKind(v[0]) != reflect.Slice &&
l == 1 { //arg is a slice of 1 but we want back a non slice
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
} else if libs.IsList(sv) &&
getKind(v[0]) == reflect.Slice &&
libs.IsList(libs.Index(sv, 0)) &&
l == 1 { //arg is a list of single list and we only want back a list so we need to unwrap
val := libs.Index(sv, 0)
return unmarshal(SassValue{value: val}, v[0])
//return unmarshal(C.sass_list_get_value(arg, C.size_t(0)), v[0])
} else {
return unmarshal(arg, v[0])
}
} | [
"func",
"Unmarshal",
"(",
"arg",
"SassValue",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"sv",
":=",
"arg",
".",
"Val",
"(",
")",
"\n",
"var",
"l",
"int",
"\n",
"if",
"libs",
".",
"IsList",
"(",
"sv",
... | // Decode converts Sass Value to Go compatible data types. | [
"Decode",
"converts",
"Sass",
"Value",
"to",
"Go",
"compatible",
"data",
"types",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/encoding.go#L134-L174 |
15,656 | wellington/go-libsass | encoding.go | makevalue | func makevalue(v interface{}) (SassValue, error) {
f := reflect.ValueOf(v)
var err error
switch f.Kind() {
default:
return SassValue{value: libs.MakeNil()}, nil
case reflect.Bool:
b := v.(bool)
return SassValue{value: libs.MakeBool(b)}, nil
case reflect.String:
s := v.(string)
return SassValue{value: libs.MakeString(s)}, nil
case reflect.Struct: //only SassNumber and color.RGBA are supported
if sn, ok := v.(libs.SassNumber); ok {
return SassValue{
value: libs.MakeNumber(sn.Float(), sn.UnitOf()),
}, err
} else if sc, ok := v.(color.RGBA); ok {
return SassValue{value: libs.MakeColor(sc)}, nil
} else {
err = errors.New(fmt.Sprintf("The struct type %s is unsupported for marshalling", reflect.TypeOf(v).String()))
return SassValue{value: libs.MakeNil()}, err
}
case reflect.Slice:
// Initialize the list
lst := libs.MakeList(f.Len())
for i := 0; i < f.Len(); i++ {
t, er := makevalue(f.Index(i).Interface())
if err == nil && er != nil {
err = er
}
libs.SetIndex(lst, i, t.Val())
}
return SassValue{value: lst}, err
}
} | go | func makevalue(v interface{}) (SassValue, error) {
f := reflect.ValueOf(v)
var err error
switch f.Kind() {
default:
return SassValue{value: libs.MakeNil()}, nil
case reflect.Bool:
b := v.(bool)
return SassValue{value: libs.MakeBool(b)}, nil
case reflect.String:
s := v.(string)
return SassValue{value: libs.MakeString(s)}, nil
case reflect.Struct: //only SassNumber and color.RGBA are supported
if sn, ok := v.(libs.SassNumber); ok {
return SassValue{
value: libs.MakeNumber(sn.Float(), sn.UnitOf()),
}, err
} else if sc, ok := v.(color.RGBA); ok {
return SassValue{value: libs.MakeColor(sc)}, nil
} else {
err = errors.New(fmt.Sprintf("The struct type %s is unsupported for marshalling", reflect.TypeOf(v).String()))
return SassValue{value: libs.MakeNil()}, err
}
case reflect.Slice:
// Initialize the list
lst := libs.MakeList(f.Len())
for i := 0; i < f.Len(); i++ {
t, er := makevalue(f.Index(i).Interface())
if err == nil && er != nil {
err = er
}
libs.SetIndex(lst, i, t.Val())
}
return SassValue{value: lst}, err
}
} | [
"func",
"makevalue",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"SassValue",
",",
"error",
")",
"{",
"f",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"var",
"err",
"error",
"\n",
"switch",
"f",
".",
"Kind",
"(",
")",
"{",
"default",
":"... | // make is needed to create types for use by test | [
"make",
"is",
"needed",
"to",
"create",
"types",
"for",
"use",
"by",
"test"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/encoding.go#L208-L243 |
15,657 | wellington/go-libsass | libs/wrap.go | SassMakeImporterList | func SassMakeImporterList(gol int) SassImporterList {
l := C.size_t(gol)
cimp := C.sass_make_importer_list(l)
return (SassImporterList)(cimp)
} | go | func SassMakeImporterList(gol int) SassImporterList {
l := C.size_t(gol)
cimp := C.sass_make_importer_list(l)
return (SassImporterList)(cimp)
} | [
"func",
"SassMakeImporterList",
"(",
"gol",
"int",
")",
"SassImporterList",
"{",
"l",
":=",
"C",
".",
"size_t",
"(",
"gol",
")",
"\n",
"cimp",
":=",
"C",
".",
"sass_make_importer_list",
"(",
"l",
")",
"\n",
"return",
"(",
"SassImporterList",
")",
"(",
"c... | // SassMakeImporterList maps to C.sass_make_importer_list | [
"SassMakeImporterList",
"maps",
"to",
"C",
".",
"sass_make_importer_list"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L26-L30 |
15,658 | wellington/go-libsass | libs/wrap.go | ImporterBridge | func ImporterBridge(url *C.char, prev *C.char, cidx C.uintptr_t) C.Sass_Import_List {
var importResolver ImportResolver
// Retrieve the index
idx := int(cidx)
importResolver, ok := globalImports.Get(idx).(ImportResolver)
if !ok {
fmt.Printf("failed to resolve import handler: %d\n", idx)
}
parent := C.GoString(prev)
rel := C.GoString(url)
list := C.sass_make_import_list(1)
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(list)),
Len: 1, Cap: 1,
}
golist := *(*[]C.Sass_Import_Entry)(unsafe.Pointer(&hdr))
if importResolver != nil {
newURL, body, resolved := importResolver(rel, parent)
if resolved {
// Passing a nil as body is a signal to load the import from the URL.
var bodyv *C.char
if body != "" {
bodyv = C.CString(body)
}
ent := C.sass_make_import_entry(C.CString(newURL), bodyv, nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
return list
}
}
if strings.HasPrefix(rel, "compass") {
ent := C.sass_make_import_entry(url, C.CString(""), nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
} else {
ent := C.sass_make_import_entry(url, nil, nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
}
return list
} | go | func ImporterBridge(url *C.char, prev *C.char, cidx C.uintptr_t) C.Sass_Import_List {
var importResolver ImportResolver
// Retrieve the index
idx := int(cidx)
importResolver, ok := globalImports.Get(idx).(ImportResolver)
if !ok {
fmt.Printf("failed to resolve import handler: %d\n", idx)
}
parent := C.GoString(prev)
rel := C.GoString(url)
list := C.sass_make_import_list(1)
hdr := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(list)),
Len: 1, Cap: 1,
}
golist := *(*[]C.Sass_Import_Entry)(unsafe.Pointer(&hdr))
if importResolver != nil {
newURL, body, resolved := importResolver(rel, parent)
if resolved {
// Passing a nil as body is a signal to load the import from the URL.
var bodyv *C.char
if body != "" {
bodyv = C.CString(body)
}
ent := C.sass_make_import_entry(C.CString(newURL), bodyv, nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
return list
}
}
if strings.HasPrefix(rel, "compass") {
ent := C.sass_make_import_entry(url, C.CString(""), nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
} else {
ent := C.sass_make_import_entry(url, nil, nil)
cent := (C.Sass_Import_Entry)(ent)
golist[0] = cent
}
return list
} | [
"func",
"ImporterBridge",
"(",
"url",
"*",
"C",
".",
"char",
",",
"prev",
"*",
"C",
".",
"char",
",",
"cidx",
"C",
".",
"uintptr_t",
")",
"C",
".",
"Sass_Import_List",
"{",
"var",
"importResolver",
"ImportResolver",
"\n\n",
"// Retrieve the index",
"idx",
... | // ImporterBridge is called by C to pass Importer arguments into Go land. A
// Sass_Import is returned for libsass to resolve.
//
//export ImporterBridge | [
"ImporterBridge",
"is",
"called",
"by",
"C",
"to",
"pass",
"Importer",
"arguments",
"into",
"Go",
"land",
".",
"A",
"Sass_Import",
"is",
"returned",
"for",
"libsass",
"to",
"resolve",
".",
"export",
"ImporterBridge"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L84-L132 |
15,659 | wellington/go-libsass | libs/wrap.go | SassMakeFileContext | func SassMakeFileContext(gos string) SassFileContext {
s := C.CString(gos)
fctx := C.sass_make_file_context(s)
return (SassFileContext)(fctx)
} | go | func SassMakeFileContext(gos string) SassFileContext {
s := C.CString(gos)
fctx := C.sass_make_file_context(s)
return (SassFileContext)(fctx)
} | [
"func",
"SassMakeFileContext",
"(",
"gos",
"string",
")",
"SassFileContext",
"{",
"s",
":=",
"C",
".",
"CString",
"(",
"gos",
")",
"\n",
"fctx",
":=",
"C",
".",
"sass_make_file_context",
"(",
"s",
")",
"\n",
"return",
"(",
"SassFileContext",
")",
"(",
"f... | // SassMakeFileContext maps to C.sass_make_file_context | [
"SassMakeFileContext",
"maps",
"to",
"C",
".",
"sass_make_file_context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L139-L143 |
15,660 | wellington/go-libsass | libs/wrap.go | SassMakeDataContext | func SassMakeDataContext(gos string) SassDataContext {
s := C.CString(gos)
dctx := C.sass_make_data_context(s)
return (SassDataContext)(dctx)
} | go | func SassMakeDataContext(gos string) SassDataContext {
s := C.CString(gos)
dctx := C.sass_make_data_context(s)
return (SassDataContext)(dctx)
} | [
"func",
"SassMakeDataContext",
"(",
"gos",
"string",
")",
"SassDataContext",
"{",
"s",
":=",
"C",
".",
"CString",
"(",
"gos",
")",
"\n",
"dctx",
":=",
"C",
".",
"sass_make_data_context",
"(",
"s",
")",
"\n",
"return",
"(",
"SassDataContext",
")",
"(",
"d... | // SassMakeDataContext creates a data context from a source string | [
"SassMakeDataContext",
"creates",
"a",
"data",
"context",
"from",
"a",
"source",
"string"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L153-L157 |
15,661 | wellington/go-libsass | libs/wrap.go | SassDataContextGetContext | func SassDataContextGetContext(godc SassDataContext) SassContext {
opts := C.sass_data_context_get_context(godc)
return (SassContext)(opts)
} | go | func SassDataContextGetContext(godc SassDataContext) SassContext {
opts := C.sass_data_context_get_context(godc)
return (SassContext)(opts)
} | [
"func",
"SassDataContextGetContext",
"(",
"godc",
"SassDataContext",
")",
"SassContext",
"{",
"opts",
":=",
"C",
".",
"sass_data_context_get_context",
"(",
"godc",
")",
"\n",
"return",
"(",
"SassContext",
")",
"(",
"opts",
")",
"\n",
"}"
] | // SassDataContextGetContext returns a context from a data context.
// These are useful for calling generic methods like compiling. | [
"SassDataContextGetContext",
"returns",
"a",
"context",
"from",
"a",
"data",
"context",
".",
"These",
"are",
"useful",
"for",
"calling",
"generic",
"methods",
"like",
"compiling",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L168-L171 |
15,662 | wellington/go-libsass | libs/wrap.go | SassFileContextGetContext | func SassFileContextGetContext(gofc SassFileContext) SassContext {
opts := C.sass_file_context_get_context(gofc)
return (SassContext)(opts)
} | go | func SassFileContextGetContext(gofc SassFileContext) SassContext {
opts := C.sass_file_context_get_context(gofc)
return (SassContext)(opts)
} | [
"func",
"SassFileContextGetContext",
"(",
"gofc",
"SassFileContext",
")",
"SassContext",
"{",
"opts",
":=",
"C",
".",
"sass_file_context_get_context",
"(",
"gofc",
")",
"\n",
"return",
"(",
"SassContext",
")",
"(",
"opts",
")",
"\n",
"}"
] | // SassFileContextGetContext returns a context from a file context.
// These are useful for calling generic methods like compiling. | [
"SassFileContextGetContext",
"returns",
"a",
"context",
"from",
"a",
"file",
"context",
".",
"These",
"are",
"useful",
"for",
"calling",
"generic",
"methods",
"like",
"compiling",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L175-L178 |
15,663 | wellington/go-libsass | libs/wrap.go | SassFileContextGetOptions | func SassFileContextGetOptions(gofc SassFileContext) SassOptions {
fcopts := C.sass_file_context_get_options(gofc)
return (SassOptions)(fcopts)
} | go | func SassFileContextGetOptions(gofc SassFileContext) SassOptions {
fcopts := C.sass_file_context_get_options(gofc)
return (SassOptions)(fcopts)
} | [
"func",
"SassFileContextGetOptions",
"(",
"gofc",
"SassFileContext",
")",
"SassOptions",
"{",
"fcopts",
":=",
"C",
".",
"sass_file_context_get_options",
"(",
"gofc",
")",
"\n",
"return",
"(",
"SassOptions",
")",
"(",
"fcopts",
")",
"\n",
"}"
] | // SassFileContextGetOptions returns the sass options in a file context | [
"SassFileContextGetOptions",
"returns",
"the",
"sass",
"options",
"in",
"a",
"file",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L190-L193 |
15,664 | wellington/go-libsass | libs/wrap.go | SassDataContextGetOptions | func SassDataContextGetOptions(godc SassDataContext) SassOptions {
dcopts := C.sass_data_context_get_options(godc)
return (SassOptions)(dcopts)
} | go | func SassDataContextGetOptions(godc SassDataContext) SassOptions {
dcopts := C.sass_data_context_get_options(godc)
return (SassOptions)(dcopts)
} | [
"func",
"SassDataContextGetOptions",
"(",
"godc",
"SassDataContext",
")",
"SassOptions",
"{",
"dcopts",
":=",
"C",
".",
"sass_data_context_get_options",
"(",
"godc",
")",
"\n",
"return",
"(",
"SassOptions",
")",
"(",
"dcopts",
")",
"\n",
"}"
] | // SassDataContextGetOptions returns the Sass options in a data context | [
"SassDataContextGetOptions",
"returns",
"the",
"Sass",
"options",
"in",
"a",
"data",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L201-L204 |
15,665 | wellington/go-libsass | libs/wrap.go | SassMakeFileCompiler | func SassMakeFileCompiler(gofc SassFileContext) SassCompiler {
sc := C.sass_make_file_compiler(gofc)
return (SassCompiler)(sc)
} | go | func SassMakeFileCompiler(gofc SassFileContext) SassCompiler {
sc := C.sass_make_file_compiler(gofc)
return (SassCompiler)(sc)
} | [
"func",
"SassMakeFileCompiler",
"(",
"gofc",
"SassFileContext",
")",
"SassCompiler",
"{",
"sc",
":=",
"C",
".",
"sass_make_file_compiler",
"(",
"gofc",
")",
"\n",
"return",
"(",
"SassCompiler",
")",
"(",
"sc",
")",
"\n",
"}"
] | // SassMakeFileCompiler returns a compiler from a file context | [
"SassMakeFileCompiler",
"returns",
"a",
"compiler",
"from",
"a",
"file",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L214-L217 |
15,666 | wellington/go-libsass | libs/wrap.go | SassMakeDataCompiler | func SassMakeDataCompiler(godc SassDataContext) SassCompiler {
dc := C.sass_make_data_compiler(godc)
return (SassCompiler)(dc)
} | go | func SassMakeDataCompiler(godc SassDataContext) SassCompiler {
dc := C.sass_make_data_compiler(godc)
return (SassCompiler)(dc)
} | [
"func",
"SassMakeDataCompiler",
"(",
"godc",
"SassDataContext",
")",
"SassCompiler",
"{",
"dc",
":=",
"C",
".",
"sass_make_data_compiler",
"(",
"godc",
")",
"\n",
"return",
"(",
"SassCompiler",
")",
"(",
"dc",
")",
"\n",
"}"
] | // SassMakeDataCompiler returns a compiler from a data context | [
"SassMakeDataCompiler",
"returns",
"a",
"compiler",
"from",
"a",
"data",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L220-L223 |
15,667 | wellington/go-libsass | libs/wrap.go | SassCompileFileContext | func SassCompileFileContext(gofc SassFileContext) int {
cstatus := C.sass_compile_file_context(gofc)
return int(cstatus)
} | go | func SassCompileFileContext(gofc SassFileContext) int {
cstatus := C.sass_compile_file_context(gofc)
return int(cstatus)
} | [
"func",
"SassCompileFileContext",
"(",
"gofc",
"SassFileContext",
")",
"int",
"{",
"cstatus",
":=",
"C",
".",
"sass_compile_file_context",
"(",
"gofc",
")",
"\n",
"return",
"int",
"(",
"cstatus",
")",
"\n",
"}"
] | // SassCompileFileContext compile from file context | [
"SassCompileFileContext",
"compile",
"from",
"file",
"context"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L226-L229 |
15,668 | wellington/go-libsass | libs/wrap.go | SassOptionSetCHeaders | func SassOptionSetCHeaders(gofc SassOptions, goimp SassImporterList) {
C.sass_option_set_c_headers(gofc, C.Sass_Importer_List(goimp))
} | go | func SassOptionSetCHeaders(gofc SassOptions, goimp SassImporterList) {
C.sass_option_set_c_headers(gofc, C.Sass_Importer_List(goimp))
} | [
"func",
"SassOptionSetCHeaders",
"(",
"gofc",
"SassOptions",
",",
"goimp",
"SassImporterList",
")",
"{",
"C",
".",
"sass_option_set_c_headers",
"(",
"gofc",
",",
"C",
".",
"Sass_Importer_List",
"(",
"goimp",
")",
")",
"\n",
"}"
] | // SassOptionSetCHeaders adds custom C headers to a SassOptions | [
"SassOptionSetCHeaders",
"adds",
"custom",
"C",
"headers",
"to",
"a",
"SassOptions"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L247-L249 |
15,669 | wellington/go-libsass | libs/wrap.go | SassContextGetOutputString | func SassContextGetOutputString(goctx SassContext) string {
cstr := C.sass_context_get_output_string(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | go | func SassContextGetOutputString(goctx SassContext) string {
cstr := C.sass_context_get_output_string(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | [
"func",
"SassContextGetOutputString",
"(",
"goctx",
"SassContext",
")",
"string",
"{",
"cstr",
":=",
"C",
".",
"sass_context_get_output_string",
"(",
"goctx",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cstr",
")",
")",
"\n",
... | // SassContextGetOutputString retrieves the final compiled CSS after
// compiler parses and executes. | [
"SassContextGetOutputString",
"retrieves",
"the",
"final",
"compiled",
"CSS",
"after",
"compiler",
"parses",
"and",
"executes",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L253-L257 |
15,670 | wellington/go-libsass | libs/wrap.go | SassContextGetErrorJSON | func SassContextGetErrorJSON(goctx SassContext) string {
cstr := C.sass_context_get_error_json(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | go | func SassContextGetErrorJSON(goctx SassContext) string {
cstr := C.sass_context_get_error_json(goctx)
defer C.free(unsafe.Pointer(cstr))
return C.GoString(cstr)
} | [
"func",
"SassContextGetErrorJSON",
"(",
"goctx",
"SassContext",
")",
"string",
"{",
"cstr",
":=",
"C",
".",
"sass_context_get_error_json",
"(",
"goctx",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cstr",
")",
")",
"\n",
"retu... | // SassContextGetErrorJSON requests an error in JSON format from libsass | [
"SassContextGetErrorJSON",
"requests",
"an",
"error",
"in",
"JSON",
"format",
"from",
"libsass"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L260-L264 |
15,671 | wellington/go-libsass | libs/wrap.go | SassOptionGetSourceMapFile | func SassOptionGetSourceMapFile(goopts SassOptions) string {
p := C.sass_option_get_source_map_file(goopts)
return C.GoString(p)
} | go | func SassOptionGetSourceMapFile(goopts SassOptions) string {
p := C.sass_option_get_source_map_file(goopts)
return C.GoString(p)
} | [
"func",
"SassOptionGetSourceMapFile",
"(",
"goopts",
"SassOptions",
")",
"string",
"{",
"p",
":=",
"C",
".",
"sass_option_get_source_map_file",
"(",
"goopts",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"p",
")",
"\n",
"}"
] | // SassOptionGetSourceMapFile retrieves the source map file | [
"SassOptionGetSourceMapFile",
"retrieves",
"the",
"source",
"map",
"file"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L272-L275 |
15,672 | wellington/go-libsass | libs/wrap.go | SassContextGetSourceMapString | func SassContextGetSourceMapString(goctx SassContext) string {
s := C.sass_context_get_source_map_string(goctx)
return C.GoString(s)
} | go | func SassContextGetSourceMapString(goctx SassContext) string {
s := C.sass_context_get_source_map_string(goctx)
return C.GoString(s)
} | [
"func",
"SassContextGetSourceMapString",
"(",
"goctx",
"SassContext",
")",
"string",
"{",
"s",
":=",
"C",
".",
"sass_context_get_source_map_string",
"(",
"goctx",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"s",
")",
"\n",
"}"
] | // SassContextGetSourceMapString retrieves the contents of a
// source map | [
"SassContextGetSourceMapString",
"retrieves",
"the",
"contents",
"of",
"a",
"source",
"map"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L279-L282 |
15,673 | wellington/go-libsass | libs/wrap.go | SassOptionSetPrecision | func SassOptionSetPrecision(goopts SassOptions, i int) {
C.sass_option_set_precision(goopts, C.int(i))
} | go | func SassOptionSetPrecision(goopts SassOptions, i int) {
C.sass_option_set_precision(goopts, C.int(i))
} | [
"func",
"SassOptionSetPrecision",
"(",
"goopts",
"SassOptions",
",",
"i",
"int",
")",
"{",
"C",
".",
"sass_option_set_precision",
"(",
"goopts",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
"\n",
"}"
] | // SassOptionSetPrecision sets the precision of floating point math
// ie. 3.2222px. This is currently bugged and does not work. | [
"SassOptionSetPrecision",
"sets",
"the",
"precision",
"of",
"floating",
"point",
"math",
"ie",
".",
"3",
".",
"2222px",
".",
"This",
"is",
"currently",
"bugged",
"and",
"does",
"not",
"work",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L286-L288 |
15,674 | wellington/go-libsass | libs/wrap.go | SassOptionSetSourceComments | func SassOptionSetSourceComments(goopts SassOptions, b bool) {
C.sass_option_set_source_comments(goopts, C.bool(b))
} | go | func SassOptionSetSourceComments(goopts SassOptions, b bool) {
C.sass_option_set_source_comments(goopts, C.bool(b))
} | [
"func",
"SassOptionSetSourceComments",
"(",
"goopts",
"SassOptions",
",",
"b",
"bool",
")",
"{",
"C",
".",
"sass_option_set_source_comments",
"(",
"goopts",
",",
"C",
".",
"bool",
"(",
"b",
")",
")",
"\n",
"}"
] | // SassOptionSetSourceComments toggles the output of line comments in CSS | [
"SassOptionSetSourceComments",
"toggles",
"the",
"output",
"of",
"line",
"comments",
"in",
"CSS"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L296-L298 |
15,675 | wellington/go-libsass | libs/wrap.go | SassOptionSetOutputPath | func SassOptionSetOutputPath(goopts SassOptions, path string) {
C.sass_option_set_output_path(goopts, C.CString(path))
} | go | func SassOptionSetOutputPath(goopts SassOptions, path string) {
C.sass_option_set_output_path(goopts, C.CString(path))
} | [
"func",
"SassOptionSetOutputPath",
"(",
"goopts",
"SassOptions",
",",
"path",
"string",
")",
"{",
"C",
".",
"sass_option_set_output_path",
"(",
"goopts",
",",
"C",
".",
"CString",
"(",
"path",
")",
")",
"\n",
"}"
] | // SassOptionSetOutputPath is used for output path.
// Output path is used for source map generating. LibSass will
// not write to this file, it is just used to create
// information in source-maps etc. | [
"SassOptionSetOutputPath",
"is",
"used",
"for",
"output",
"path",
".",
"Output",
"path",
"is",
"used",
"for",
"source",
"map",
"generating",
".",
"LibSass",
"will",
"not",
"write",
"to",
"this",
"file",
"it",
"is",
"just",
"used",
"to",
"create",
"informatio... | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L304-L306 |
15,676 | wellington/go-libsass | libs/wrap.go | SassOptionSetInputPath | func SassOptionSetInputPath(goopts SassOptions, path string) {
C.sass_option_set_input_path(goopts, C.CString(path))
} | go | func SassOptionSetInputPath(goopts SassOptions, path string) {
C.sass_option_set_input_path(goopts, C.CString(path))
} | [
"func",
"SassOptionSetInputPath",
"(",
"goopts",
"SassOptions",
",",
"path",
"string",
")",
"{",
"C",
".",
"sass_option_set_input_path",
"(",
"goopts",
",",
"C",
".",
"CString",
"(",
"path",
")",
")",
"\n",
"}"
] | // SassOptionSetInputPath is used for input path.
// The input path is used for source map generating. It can be used to define
// something with string compilation or to overload the input file path. It is
// set to "stdin" for data contexts and to the input file on file contexts. | [
"SassOptionSetInputPath",
"is",
"used",
"for",
"input",
"path",
".",
"The",
"input",
"path",
"is",
"used",
"for",
"source",
"map",
"generating",
".",
"It",
"can",
"be",
"used",
"to",
"define",
"something",
"with",
"string",
"compilation",
"or",
"to",
"overlo... | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L312-L314 |
15,677 | wellington/go-libsass | libs/wrap.go | SassOptionSetIncludePath | func SassOptionSetIncludePath(goopts SassOptions, path string) {
C.sass_option_set_include_path(goopts, C.CString(path))
} | go | func SassOptionSetIncludePath(goopts SassOptions, path string) {
C.sass_option_set_include_path(goopts, C.CString(path))
} | [
"func",
"SassOptionSetIncludePath",
"(",
"goopts",
"SassOptions",
",",
"path",
"string",
")",
"{",
"C",
".",
"sass_option_set_include_path",
"(",
"goopts",
",",
"C",
".",
"CString",
"(",
"path",
")",
")",
"\n",
"}"
] | // SassOptionSetIncludePaths adds additional paths to look for input Sass | [
"SassOptionSetIncludePaths",
"adds",
"additional",
"paths",
"to",
"look",
"for",
"input",
"Sass"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L317-L319 |
15,678 | wellington/go-libsass | libs/wrap.go | SassMakeImport | func SassMakeImport(path string, base string, source string, srcmap string) SassImportEntry {
impent := C.sass_make_import(C.CString(path), C.CString(base),
C.CString(source), C.CString(srcmap))
return (SassImportEntry)(impent)
} | go | func SassMakeImport(path string, base string, source string, srcmap string) SassImportEntry {
impent := C.sass_make_import(C.CString(path), C.CString(base),
C.CString(source), C.CString(srcmap))
return (SassImportEntry)(impent)
} | [
"func",
"SassMakeImport",
"(",
"path",
"string",
",",
"base",
"string",
",",
"source",
"string",
",",
"srcmap",
"string",
")",
"SassImportEntry",
"{",
"impent",
":=",
"C",
".",
"sass_make_import",
"(",
"C",
".",
"CString",
"(",
"path",
")",
",",
"C",
"."... | // SassMakeImport creates an import for overriding behavior when
// certain imports are called. | [
"SassMakeImport",
"creates",
"an",
"import",
"for",
"overriding",
"behavior",
"when",
"certain",
"imports",
"are",
"called",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L348-L352 |
15,679 | wellington/go-libsass | libs/wrap.go | SassMakeImporter | func SassMakeImporter(fn SassImporterFN, priority int, v interface{}) (SassImporter, error) {
vv := reflect.ValueOf(v).Elem()
if !vv.CanAddr() {
return nil, errors.New("can not take address of")
}
// TODO: this will leak memory, the interface must be freed manually
lst := C.sass_make_importer(C.Sass_Importer_Fn(fn), C.double(priority), unsafe.Pointer(vv.Addr().Pointer()))
return (SassImporter)(lst), nil
} | go | func SassMakeImporter(fn SassImporterFN, priority int, v interface{}) (SassImporter, error) {
vv := reflect.ValueOf(v).Elem()
if !vv.CanAddr() {
return nil, errors.New("can not take address of")
}
// TODO: this will leak memory, the interface must be freed manually
lst := C.sass_make_importer(C.Sass_Importer_Fn(fn), C.double(priority), unsafe.Pointer(vv.Addr().Pointer()))
return (SassImporter)(lst), nil
} | [
"func",
"SassMakeImporter",
"(",
"fn",
"SassImporterFN",
",",
"priority",
"int",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"SassImporter",
",",
"error",
")",
"{",
"vv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
".",
"Elem",
"(",
")",
"\n",
"if... | // SassMakeImport attaches a Go pointer to a Sass function. Go will
// eventually kill this behavior and we should find a new way to do this. | [
"SassMakeImport",
"attaches",
"a",
"Go",
"pointer",
"to",
"a",
"Sass",
"function",
".",
"Go",
"will",
"eventually",
"kill",
"this",
"behavior",
"and",
"we",
"should",
"find",
"a",
"new",
"way",
"to",
"do",
"this",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L365-L373 |
15,680 | wellington/go-libsass | libs/wrap.go | SassImporterSetListEntry | func SassImporterSetListEntry(golst SassImporterList, idx int, ent SassImporter) {
C.sass_importer_set_list_entry(C.Sass_Importer_List(golst), C.size_t(idx), C.Sass_Importer_Entry(ent))
} | go | func SassImporterSetListEntry(golst SassImporterList, idx int, ent SassImporter) {
C.sass_importer_set_list_entry(C.Sass_Importer_List(golst), C.size_t(idx), C.Sass_Importer_Entry(ent))
} | [
"func",
"SassImporterSetListEntry",
"(",
"golst",
"SassImporterList",
",",
"idx",
"int",
",",
"ent",
"SassImporter",
")",
"{",
"C",
".",
"sass_importer_set_list_entry",
"(",
"C",
".",
"Sass_Importer_List",
"(",
"golst",
")",
",",
"C",
".",
"size_t",
"(",
"idx"... | // SassImporterSetListEntry updates an import list with a new entry. The
// index must exist in the importer list. | [
"SassImporterSetListEntry",
"updates",
"an",
"import",
"list",
"with",
"a",
"new",
"entry",
".",
"The",
"index",
"must",
"exist",
"in",
"the",
"importer",
"list",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/wrap.go#L377-L379 |
15,681 | wellington/go-libsass | libs/importer.go | BindImporter | func BindImporter(opts SassOptions, resolver ImportResolver) int {
idx := globalImports.Set(resolver)
ptr := unsafe.Pointer(uintptr(idx))
imper := C.sass_make_importer(
C.Sass_Importer_Fn(C.SassImporterHandler),
C.double(0),
ptr,
)
impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_importers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers,
)
return idx
} | go | func BindImporter(opts SassOptions, resolver ImportResolver) int {
idx := globalImports.Set(resolver)
ptr := unsafe.Pointer(uintptr(idx))
imper := C.sass_make_importer(
C.Sass_Importer_Fn(C.SassImporterHandler),
C.double(0),
ptr,
)
impers := C.sass_make_importer_list(1)
C.sass_importer_set_list_entry(impers, 0, imper)
C.sass_option_set_c_importers(
(*C.struct_Sass_Options)(unsafe.Pointer(opts)),
impers,
)
return idx
} | [
"func",
"BindImporter",
"(",
"opts",
"SassOptions",
",",
"resolver",
"ImportResolver",
")",
"int",
"{",
"idx",
":=",
"globalImports",
".",
"Set",
"(",
"resolver",
")",
"\n",
"ptr",
":=",
"unsafe",
".",
"Pointer",
"(",
"uintptr",
"(",
"idx",
")",
")",
"\n... | // BindImporter attaches a custom importer Go function to an import in Sass | [
"BindImporter",
"attaches",
"a",
"custom",
"importer",
"Go",
"function",
"to",
"an",
"import",
"in",
"Sass"
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/libs/importer.go#L42-L60 |
15,682 | wellington/go-libsass | error.go | ProcessSassError | func (ctx *compctx) ProcessSassError(bs []byte) error {
if len(bs) == 0 {
return nil
}
err := json.Unmarshal(bs, &ctx.err)
if err != nil {
return err
}
errors := ctx.err
ctx.errorString = fmt.Sprintf("Error > %s:%d\n%s",
errors.File, errors.Line, errors.Message)
return nil
} | go | func (ctx *compctx) ProcessSassError(bs []byte) error {
if len(bs) == 0 {
return nil
}
err := json.Unmarshal(bs, &ctx.err)
if err != nil {
return err
}
errors := ctx.err
ctx.errorString = fmt.Sprintf("Error > %s:%d\n%s",
errors.File, errors.Line, errors.Message)
return nil
} | [
"func",
"(",
"ctx",
"*",
"compctx",
")",
"ProcessSassError",
"(",
"bs",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"bs",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bs",
",",
... | // ProcessSassError reads the original libsass error and creates helpful debuggin
// information for debuggin that error. | [
"ProcessSassError",
"reads",
"the",
"original",
"libsass",
"error",
"and",
"creates",
"helpful",
"debuggin",
"information",
"for",
"debuggin",
"that",
"error",
"."
] | f870eaa15594bb64b1908df39d0812704f0ceb8f | https://github.com/wellington/go-libsass/blob/f870eaa15594bb64b1908df39d0812704f0ceb8f/error.go#L17-L32 |
15,683 | proullon/ramsql | engine/select.go | getSelectFunctors | func getSelectFunctors(attr *parser.Decl) ([]selectFunctor, error) {
var functors []selectFunctor
for i := range attr.Decl {
if attr.Decl[i].Token == parser.FromToken {
break
}
if attr.Decl[i].Token == parser.CountToken {
f := &countSelectFunction{}
functors = append(functors, f)
}
}
if len(functors) == 0 {
f := &defaultSelectFunction{}
functors = append(functors, f)
}
return functors, nil
} | go | func getSelectFunctors(attr *parser.Decl) ([]selectFunctor, error) {
var functors []selectFunctor
for i := range attr.Decl {
if attr.Decl[i].Token == parser.FromToken {
break
}
if attr.Decl[i].Token == parser.CountToken {
f := &countSelectFunction{}
functors = append(functors, f)
}
}
if len(functors) == 0 {
f := &defaultSelectFunction{}
functors = append(functors, f)
}
return functors, nil
} | [
"func",
"getSelectFunctors",
"(",
"attr",
"*",
"parser",
".",
"Decl",
")",
"(",
"[",
"]",
"selectFunctor",
",",
"error",
")",
"{",
"var",
"functors",
"[",
"]",
"selectFunctor",
"\n\n",
"for",
"i",
":=",
"range",
"attr",
".",
"Decl",
"{",
"if",
"attr",
... | // getSelectFunctors instanciate new functors for COUNT, MAX, MIN, AVG, ... and default select functor that return rows to client
// If a functor is specified, no attribute can be selected ? | [
"getSelectFunctors",
"instanciate",
"new",
"functors",
"for",
"COUNT",
"MAX",
"MIN",
"AVG",
"...",
"and",
"default",
"select",
"functor",
"that",
"return",
"rows",
"to",
"client",
"If",
"a",
"functor",
"is",
"specified",
"no",
"attribute",
"can",
"be",
"select... | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/select.go#L169-L191 |
15,684 | proullon/ramsql | engine/select.go | selectRows | func selectRows(row virtualRow, predicates []PredicateLinker, functors []selectFunctor) error {
var res bool
var err error
// If the row validate all predicates, write it
for _, predicate := range predicates {
if res, err = predicate.Eval(row); err != nil {
return err
}
if res == false {
return nil
}
}
for i := range functors {
err := functors[i].FeedVirtualRow(row)
if err != nil {
return err
}
}
return nil
} | go | func selectRows(row virtualRow, predicates []PredicateLinker, functors []selectFunctor) error {
var res bool
var err error
// If the row validate all predicates, write it
for _, predicate := range predicates {
if res, err = predicate.Eval(row); err != nil {
return err
}
if res == false {
return nil
}
}
for i := range functors {
err := functors[i].FeedVirtualRow(row)
if err != nil {
return err
}
}
return nil
} | [
"func",
"selectRows",
"(",
"row",
"virtualRow",
",",
"predicates",
"[",
"]",
"PredicateLinker",
",",
"functors",
"[",
"]",
"selectFunctor",
")",
"error",
"{",
"var",
"res",
"bool",
"\n",
"var",
"err",
"error",
"\n\n",
"// If the row validate all predicates, write ... | // Perform actual check of predicates present in virtualrow. | [
"Perform",
"actual",
"check",
"of",
"predicates",
"present",
"in",
"virtualrow",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/select.go#L570-L591 |
15,685 | proullon/ramsql | engine/orderby.go | orderbyExecutor | func orderbyExecutor(attr *parser.Decl, tables []*Table) (selectFunctor, error) {
f := &orderbyFunctor{}
f.buffer = make(map[int64][][]string)
// first subdecl should be attribute
if len(attr.Decl) < 1 {
return nil, fmt.Errorf("ordering attribute not provided")
}
// FIXME we should find for sure the table of the attribute
if len(tables) < 1 {
return nil, fmt.Errorf("cannot guess the table of attribute %s for order", attr.Decl[0].Lexeme)
}
if len(attr.Decl[0].Decl) > 0 {
f.orderby = attr.Decl[0].Decl[0].Lexeme + "." + attr.Decl[0].Lexeme
} else {
f.orderby = tables[0].name + "." + attr.Decl[0].Lexeme
}
// if second subdecl is present, it's either asc or desc
// default is asc anyway
if len(attr.Decl) == 2 && attr.Decl[1].Token == parser.AscToken {
f.asc = true
}
log.Debug("orderbyExecutor> you must order by '%s', asc: %v\n", f.orderby, f.asc)
return f, nil
} | go | func orderbyExecutor(attr *parser.Decl, tables []*Table) (selectFunctor, error) {
f := &orderbyFunctor{}
f.buffer = make(map[int64][][]string)
// first subdecl should be attribute
if len(attr.Decl) < 1 {
return nil, fmt.Errorf("ordering attribute not provided")
}
// FIXME we should find for sure the table of the attribute
if len(tables) < 1 {
return nil, fmt.Errorf("cannot guess the table of attribute %s for order", attr.Decl[0].Lexeme)
}
if len(attr.Decl[0].Decl) > 0 {
f.orderby = attr.Decl[0].Decl[0].Lexeme + "." + attr.Decl[0].Lexeme
} else {
f.orderby = tables[0].name + "." + attr.Decl[0].Lexeme
}
// if second subdecl is present, it's either asc or desc
// default is asc anyway
if len(attr.Decl) == 2 && attr.Decl[1].Token == parser.AscToken {
f.asc = true
}
log.Debug("orderbyExecutor> you must order by '%s', asc: %v\n", f.orderby, f.asc)
return f, nil
} | [
"func",
"orderbyExecutor",
"(",
"attr",
"*",
"parser",
".",
"Decl",
",",
"tables",
"[",
"]",
"*",
"Table",
")",
"(",
"selectFunctor",
",",
"error",
")",
"{",
"f",
":=",
"&",
"orderbyFunctor",
"{",
"}",
"\n",
"f",
".",
"buffer",
"=",
"make",
"(",
"m... | // |-> order
// |-> age
// |-> desc | [
"|",
"-",
">",
"order",
"|",
"-",
">",
"age",
"|",
"-",
">",
"desc"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/orderby.go#L17-L43 |
15,686 | proullon/ramsql | engine/parser/parser.go | Stringy | func (d Decl) Stringy(depth int) {
indent := ""
for i := 0; i < depth; i++ {
indent = fmt.Sprintf("%s ", indent)
}
log.Debug("%s|-> %s\n", indent, d.Lexeme)
for _, subD := range d.Decl {
subD.Stringy(depth + 1)
}
} | go | func (d Decl) Stringy(depth int) {
indent := ""
for i := 0; i < depth; i++ {
indent = fmt.Sprintf("%s ", indent)
}
log.Debug("%s|-> %s\n", indent, d.Lexeme)
for _, subD := range d.Decl {
subD.Stringy(depth + 1)
}
} | [
"func",
"(",
"d",
"Decl",
")",
"Stringy",
"(",
"depth",
"int",
")",
"{",
"indent",
":=",
"\"",
"\"",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"depth",
";",
"i",
"++",
"{",
"indent",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"indent... | // Stringy prints the declaration tree in console | [
"Stringy",
"prints",
"the",
"declaration",
"tree",
"in",
"console"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L28-L38 |
15,687 | proullon/ramsql | engine/parser/parser.go | NewDecl | func NewDecl(t Token) *Decl {
return &Decl{
Token: t.Token,
Lexeme: t.Lexeme,
}
} | go | func NewDecl(t Token) *Decl {
return &Decl{
Token: t.Token,
Lexeme: t.Lexeme,
}
} | [
"func",
"NewDecl",
"(",
"t",
"Token",
")",
"*",
"Decl",
"{",
"return",
"&",
"Decl",
"{",
"Token",
":",
"t",
".",
"Token",
",",
"Lexeme",
":",
"t",
".",
"Lexeme",
",",
"}",
"\n",
"}"
] | // NewDecl initialize a Decl struct from a given token | [
"NewDecl",
"initialize",
"a",
"Decl",
"struct",
"from",
"a",
"given",
"token"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L53-L58 |
15,688 | proullon/ramsql | engine/parser/parser.go | Add | func (d *Decl) Add(subDecl *Decl) {
d.Decl = append(d.Decl, subDecl)
} | go | func (d *Decl) Add(subDecl *Decl) {
d.Decl = append(d.Decl, subDecl)
} | [
"func",
"(",
"d",
"*",
"Decl",
")",
"Add",
"(",
"subDecl",
"*",
"Decl",
")",
"{",
"d",
".",
"Decl",
"=",
"append",
"(",
"d",
".",
"Decl",
",",
"subDecl",
")",
"\n",
"}"
] | // Add creates a new leaf with given Decl | [
"Add",
"creates",
"a",
"new",
"leaf",
"with",
"given",
"Decl"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L61-L63 |
15,689 | proullon/ramsql | engine/parser/parser.go | parseBuiltinFunc | func (p *parser) parseBuiltinFunc() (*Decl, error) {
var d *Decl
var err error
// COUNT(attribute)
if p.is(CountToken) {
d, err = p.consumeToken(CountToken)
if err != nil {
return nil, err
}
// Bracket
_, err = p.consumeToken(BracketOpeningToken)
if err != nil {
return nil, err
}
// Attribute
attr, err := p.parseAttribute()
if err != nil {
return nil, err
}
d.Add(attr)
// Bracket
_, err = p.consumeToken(BracketClosingToken)
if err != nil {
return nil, err
}
}
return d, nil
} | go | func (p *parser) parseBuiltinFunc() (*Decl, error) {
var d *Decl
var err error
// COUNT(attribute)
if p.is(CountToken) {
d, err = p.consumeToken(CountToken)
if err != nil {
return nil, err
}
// Bracket
_, err = p.consumeToken(BracketOpeningToken)
if err != nil {
return nil, err
}
// Attribute
attr, err := p.parseAttribute()
if err != nil {
return nil, err
}
d.Add(attr)
// Bracket
_, err = p.consumeToken(BracketClosingToken)
if err != nil {
return nil, err
}
}
return d, nil
} | [
"func",
"(",
"p",
"*",
"parser",
")",
"parseBuiltinFunc",
"(",
")",
"(",
"*",
"Decl",
",",
"error",
")",
"{",
"var",
"d",
"*",
"Decl",
"\n",
"var",
"err",
"error",
"\n\n",
"// COUNT(attribute)",
"if",
"p",
".",
"is",
"(",
"CountToken",
")",
"{",
"d... | // parseBuiltinFunc looks for COUNT,MAX,MIN | [
"parseBuiltinFunc",
"looks",
"for",
"COUNT",
"MAX",
"MIN"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L419-L448 |
15,690 | proullon/ramsql | engine/parser/parser.go | parseQuotedToken | func (p *parser) parseQuotedToken() (*Decl, error) {
quoted := false
quoteToken := DoubleQuoteToken
if p.is(DoubleQuoteToken) || p.is(BacktickToken){
quoted = true
quoteToken = p.cur().Token
if err := p.next(); err != nil {
return nil, err
}
}
// shoud be a StringToken here
if !p.is(StringToken) {
return nil, p.syntaxError()
}
decl := NewDecl(p.cur())
if quoted {
// Check there is a closing quote
if _, err := p.mustHaveNext(quoteToken); err != nil {
return nil, err
}
}
p.next()
return decl, nil
} | go | func (p *parser) parseQuotedToken() (*Decl, error) {
quoted := false
quoteToken := DoubleQuoteToken
if p.is(DoubleQuoteToken) || p.is(BacktickToken){
quoted = true
quoteToken = p.cur().Token
if err := p.next(); err != nil {
return nil, err
}
}
// shoud be a StringToken here
if !p.is(StringToken) {
return nil, p.syntaxError()
}
decl := NewDecl(p.cur())
if quoted {
// Check there is a closing quote
if _, err := p.mustHaveNext(quoteToken); err != nil {
return nil, err
}
}
p.next()
return decl, nil
} | [
"func",
"(",
"p",
"*",
"parser",
")",
"parseQuotedToken",
"(",
")",
"(",
"*",
"Decl",
",",
"error",
")",
"{",
"quoted",
":=",
"false",
"\n",
"quoteToken",
":=",
"DoubleQuoteToken",
"\n\n",
"if",
"p",
".",
"is",
"(",
"DoubleQuoteToken",
")",
"||",
"p",
... | // parseQuotedToken parse a token of the form
// table
// "table" | [
"parseQuotedToken",
"parse",
"a",
"token",
"of",
"the",
"form",
"table",
"table"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L509-L537 |
15,691 | proullon/ramsql | engine/parser/parser.go | parseJoin | func (p *parser) parseJoin() (*Decl, error) {
joinDecl, err := p.consumeToken(JoinToken)
if err != nil {
return nil, err
}
// TABLE NAME
tableDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
joinDecl.Add(tableDecl)
// ON
onDecl, err := p.consumeToken(OnToken)
if err != nil {
return nil, err
}
// onDecl := NewDecl(t)
joinDecl.Add(onDecl)
// ATTRIBUTE
leftAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(leftAttributeDecl)
// EQUAL
equalAttr, err := p.consumeToken(EqualityToken)
if err != nil {
return nil, err
}
onDecl.Add(equalAttr)
//ATTRIBUTE
rightAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(rightAttributeDecl)
return joinDecl, nil
} | go | func (p *parser) parseJoin() (*Decl, error) {
joinDecl, err := p.consumeToken(JoinToken)
if err != nil {
return nil, err
}
// TABLE NAME
tableDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
joinDecl.Add(tableDecl)
// ON
onDecl, err := p.consumeToken(OnToken)
if err != nil {
return nil, err
}
// onDecl := NewDecl(t)
joinDecl.Add(onDecl)
// ATTRIBUTE
leftAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(leftAttributeDecl)
// EQUAL
equalAttr, err := p.consumeToken(EqualityToken)
if err != nil {
return nil, err
}
onDecl.Add(equalAttr)
//ATTRIBUTE
rightAttributeDecl, err := p.parseAttribute()
if err != nil {
return nil, err
}
onDecl.Add(rightAttributeDecl)
return joinDecl, nil
} | [
"func",
"(",
"p",
"*",
"parser",
")",
"parseJoin",
"(",
")",
"(",
"*",
"Decl",
",",
"error",
")",
"{",
"joinDecl",
",",
"err",
":=",
"p",
".",
"consumeToken",
"(",
"JoinToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err"... | // parseJoin parses the JOIN keywords and all its condition
// JOIN user_addresses ON address.id=user_addresses.address_id | [
"parseJoin",
"parses",
"the",
"JOIN",
"keywords",
"and",
"all",
"its",
"condition",
"JOIN",
"user_addresses",
"ON",
"address",
".",
"id",
"=",
"user_addresses",
".",
"address_id"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/parser.go#L686-L729 |
15,692 | proullon/ramsql | engine/engine.go | New | func New(endpoint protocol.EngineEndpoint) (e *Engine, err error) {
e = &Engine{
endpoint: endpoint,
}
e.stop = make(chan bool)
e.opsExecutors = map[int]executor{
parser.CreateToken: createExecutor,
parser.TableToken: createTableExecutor,
parser.SelectToken: selectExecutor,
parser.InsertToken: insertIntoTableExecutor,
parser.DeleteToken: deleteExecutor,
parser.UpdateToken: updateExecutor,
parser.IfToken: ifExecutor,
parser.NotToken: notExecutor,
parser.ExistsToken: existsExecutor,
parser.TruncateToken: truncateExecutor,
parser.DropToken: dropExecutor,
parser.GrantToken: grantExecutor,
}
e.relations = make(map[string]*Relation)
err = e.start()
if err != nil {
return nil, err
}
return
} | go | func New(endpoint protocol.EngineEndpoint) (e *Engine, err error) {
e = &Engine{
endpoint: endpoint,
}
e.stop = make(chan bool)
e.opsExecutors = map[int]executor{
parser.CreateToken: createExecutor,
parser.TableToken: createTableExecutor,
parser.SelectToken: selectExecutor,
parser.InsertToken: insertIntoTableExecutor,
parser.DeleteToken: deleteExecutor,
parser.UpdateToken: updateExecutor,
parser.IfToken: ifExecutor,
parser.NotToken: notExecutor,
parser.ExistsToken: existsExecutor,
parser.TruncateToken: truncateExecutor,
parser.DropToken: dropExecutor,
parser.GrantToken: grantExecutor,
}
e.relations = make(map[string]*Relation)
err = e.start()
if err != nil {
return nil, err
}
return
} | [
"func",
"New",
"(",
"endpoint",
"protocol",
".",
"EngineEndpoint",
")",
"(",
"e",
"*",
"Engine",
",",
"err",
"error",
")",
"{",
"e",
"=",
"&",
"Engine",
"{",
"endpoint",
":",
"endpoint",
",",
"}",
"\n\n",
"e",
".",
"stop",
"=",
"make",
"(",
"chan",... | // New initialize a new RamSQL server | [
"New",
"initialize",
"a",
"new",
"RamSQL",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/engine.go#L30-L61 |
15,693 | proullon/ramsql | engine/engine.go | Stop | func (e *Engine) Stop() {
if e.stop == nil {
// already stopped
return
}
go func() {
e.stop <- true
close(e.stop)
e.stop = nil
}()
} | go | func (e *Engine) Stop() {
if e.stop == nil {
// already stopped
return
}
go func() {
e.stop <- true
close(e.stop)
e.stop = nil
}()
} | [
"func",
"(",
"e",
"*",
"Engine",
")",
"Stop",
"(",
")",
"{",
"if",
"e",
".",
"stop",
"==",
"nil",
"{",
"// already stopped",
"return",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"e",
".",
"stop",
"<-",
"true",
"\n",
"close",
"(",
"e",
".",
... | // Stop shutdown the RamSQL server | [
"Stop",
"shutdown",
"the",
"RamSQL",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/engine.go#L69-L79 |
15,694 | proullon/ramsql | driver/result.go | LastInsertId | func (r *Result) LastInsertId() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.lastInsertedID, nil
} | go | func (r *Result) LastInsertId() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.lastInsertedID, nil
} | [
"func",
"(",
"r",
"*",
"Result",
")",
"LastInsertId",
"(",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"r",
".",
"err",
"\n",
"}",
"\n",
"return",
"r",
".",
"lastInsertedID",
",",
"nil... | // LastInsertId returns the database's auto-generated ID
// after, for example, an INSERT into a table with primary
// key. | [
"LastInsertId",
"returns",
"the",
"database",
"s",
"auto",
"-",
"generated",
"ID",
"after",
"for",
"example",
"an",
"INSERT",
"into",
"a",
"table",
"with",
"primary",
"key",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/result.go#L22-L27 |
15,695 | proullon/ramsql | driver/result.go | RowsAffected | func (r *Result) RowsAffected() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.rowsAffected, nil
} | go | func (r *Result) RowsAffected() (int64, error) {
if r.err != nil {
return 0, r.err
}
return r.rowsAffected, nil
} | [
"func",
"(",
"r",
"*",
"Result",
")",
"RowsAffected",
"(",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"r",
".",
"err",
"\n",
"}",
"\n",
"return",
"r",
".",
"rowsAffected",
",",
"nil",... | // RowsAffected returns the number of rows affected by the
// query. | [
"RowsAffected",
"returns",
"the",
"number",
"of",
"rows",
"affected",
"by",
"the",
"query",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/result.go#L31-L36 |
15,696 | proullon/ramsql | engine/tuple.go | NewTuple | func NewTuple(values ...interface{}) *Tuple {
t := &Tuple{}
for _, v := range values {
t.Values = append(t.Values, v)
}
return t
} | go | func NewTuple(values ...interface{}) *Tuple {
t := &Tuple{}
for _, v := range values {
t.Values = append(t.Values, v)
}
return t
} | [
"func",
"NewTuple",
"(",
"values",
"...",
"interface",
"{",
"}",
")",
"*",
"Tuple",
"{",
"t",
":=",
"&",
"Tuple",
"{",
"}",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"t",
".",
"Values",
"=",
"append",
"(",
"t",
".",
"Values",
... | // NewTuple should check that value are for the right Attribute and match domain | [
"NewTuple",
"should",
"check",
"that",
"value",
"are",
"for",
"the",
"right",
"Attribute",
"and",
"match",
"domain"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/tuple.go#L9-L16 |
15,697 | proullon/ramsql | engine/tuple.go | Append | func (t *Tuple) Append(value interface{}) {
t.Values = append(t.Values, value)
} | go | func (t *Tuple) Append(value interface{}) {
t.Values = append(t.Values, value)
} | [
"func",
"(",
"t",
"*",
"Tuple",
")",
"Append",
"(",
"value",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"Values",
"=",
"append",
"(",
"t",
".",
"Values",
",",
"value",
")",
"\n",
"}"
] | // Append add a value to the tuple | [
"Append",
"add",
"a",
"value",
"to",
"the",
"tuple"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/tuple.go#L19-L21 |
15,698 | proullon/ramsql | engine/join.go | generateVirtualRows | func generateVirtualRows(e *Engine, attr []Attribute, conn protocol.EngineConn, t1Name string, joinPredicates []joiner, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// get t1 and lock it
t1 := e.relation(t1Name)
if t1 == nil {
return fmt.Errorf("table %s not found", t1Name)
}
t1.RLock()
defer t1.RUnlock()
// all joined tables in a map of relation
relations := make(map[string]*Relation)
for _, j := range joinPredicates {
r := e.relation(j.On())
if r == nil {
return fmt.Errorf("table %s not found", j.On())
}
r.RLock()
defer r.RUnlock()
relations[j.On()] = r
}
// Write header
var header []string
var alias []string
for _, a := range attr {
alias = append(alias, a.name)
if strings.Contains(a.name, ".") == false {
a.name = t1Name + "." + a.name
}
header = append(header, a.name)
}
// Initialize functors here
for i := range functors {
if err := functors[i].Init(e, conn, header, alias); err != nil {
return err
}
}
// for each row in t1
for i := range t1.rows {
// create virtualrow
row := make(virtualRow)
for index := range t1.rows[i].Values {
v := Value{
v: t1.rows[i].Values[index],
valid: true,
lexeme: t1.table.attributes[index].name,
table: t1Name,
}
row[v.table+"."+v.lexeme] = v
}
// for first join predicates
err := join(row, relations, joinPredicates, 0, selectPredicates, functors)
if err != nil {
return err
}
}
for i := range functors {
err := functors[i].Done()
if err != nil {
return err
}
}
return nil
} | go | func generateVirtualRows(e *Engine, attr []Attribute, conn protocol.EngineConn, t1Name string, joinPredicates []joiner, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// get t1 and lock it
t1 := e.relation(t1Name)
if t1 == nil {
return fmt.Errorf("table %s not found", t1Name)
}
t1.RLock()
defer t1.RUnlock()
// all joined tables in a map of relation
relations := make(map[string]*Relation)
for _, j := range joinPredicates {
r := e.relation(j.On())
if r == nil {
return fmt.Errorf("table %s not found", j.On())
}
r.RLock()
defer r.RUnlock()
relations[j.On()] = r
}
// Write header
var header []string
var alias []string
for _, a := range attr {
alias = append(alias, a.name)
if strings.Contains(a.name, ".") == false {
a.name = t1Name + "." + a.name
}
header = append(header, a.name)
}
// Initialize functors here
for i := range functors {
if err := functors[i].Init(e, conn, header, alias); err != nil {
return err
}
}
// for each row in t1
for i := range t1.rows {
// create virtualrow
row := make(virtualRow)
for index := range t1.rows[i].Values {
v := Value{
v: t1.rows[i].Values[index],
valid: true,
lexeme: t1.table.attributes[index].name,
table: t1Name,
}
row[v.table+"."+v.lexeme] = v
}
// for first join predicates
err := join(row, relations, joinPredicates, 0, selectPredicates, functors)
if err != nil {
return err
}
}
for i := range functors {
err := functors[i].Done()
if err != nil {
return err
}
}
return nil
} | [
"func",
"generateVirtualRows",
"(",
"e",
"*",
"Engine",
",",
"attr",
"[",
"]",
"Attribute",
",",
"conn",
"protocol",
".",
"EngineConn",
",",
"t1Name",
"string",
",",
"joinPredicates",
"[",
"]",
"joiner",
",",
"selectPredicates",
"[",
"]",
"PredicateLinker",
... | // The optional WHERE, GROUP BY, and HAVING clauses in the table expression specify a pipeline of successive transformations performed on the table derived in the FROM clause.
// All these transformations produce a virtual table that provides the rows that are passed to the select list to compute the output rows of the query. | [
"The",
"optional",
"WHERE",
"GROUP",
"BY",
"and",
"HAVING",
"clauses",
"in",
"the",
"table",
"expression",
"specify",
"a",
"pipeline",
"of",
"successive",
"transformations",
"performed",
"on",
"the",
"table",
"derived",
"in",
"the",
"FROM",
"clause",
".",
"All... | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/join.go#L92-L161 |
15,699 | proullon/ramsql | engine/join.go | join | func join(row virtualRow, relations map[string]*Relation, predicates []joiner, predicateIndex int, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// Skip directly to selectRows if there is no joiner to run
if len(predicates) == 0 {
return selectRows(row, selectPredicates, functors)
}
// get current predicates
predicate := predicates[predicateIndex]
// last := is it last join ?
last := false
if predicateIndex >= len(predicates)-1 {
last = true
}
// for each row in relations[pred.Table()]
r := relations[predicate.On()]
for i := range r.rows {
ok, err := predicate.Evaluate(row, r, i)
if err != nil {
return err
}
// if predicate not ok
if !ok {
continue
}
// combine columns to existing virtual row
for index := range r.rows[i].Values {
v := Value{
v: r.rows[i].Values[index],
valid: true,
lexeme: r.table.attributes[index].name,
table: r.table.name,
}
row[v.table+"."+v.lexeme] = v
}
// if last predicate
if last {
err = selectRows(row, selectPredicates, functors)
} else {
err = join(row, relations, predicates, predicateIndex+1, selectPredicates, functors)
}
if err != nil {
return err
}
}
return nil
} | go | func join(row virtualRow, relations map[string]*Relation, predicates []joiner, predicateIndex int, selectPredicates []PredicateLinker, functors []selectFunctor) error {
// Skip directly to selectRows if there is no joiner to run
if len(predicates) == 0 {
return selectRows(row, selectPredicates, functors)
}
// get current predicates
predicate := predicates[predicateIndex]
// last := is it last join ?
last := false
if predicateIndex >= len(predicates)-1 {
last = true
}
// for each row in relations[pred.Table()]
r := relations[predicate.On()]
for i := range r.rows {
ok, err := predicate.Evaluate(row, r, i)
if err != nil {
return err
}
// if predicate not ok
if !ok {
continue
}
// combine columns to existing virtual row
for index := range r.rows[i].Values {
v := Value{
v: r.rows[i].Values[index],
valid: true,
lexeme: r.table.attributes[index].name,
table: r.table.name,
}
row[v.table+"."+v.lexeme] = v
}
// if last predicate
if last {
err = selectRows(row, selectPredicates, functors)
} else {
err = join(row, relations, predicates, predicateIndex+1, selectPredicates, functors)
}
if err != nil {
return err
}
}
return nil
} | [
"func",
"join",
"(",
"row",
"virtualRow",
",",
"relations",
"map",
"[",
"string",
"]",
"*",
"Relation",
",",
"predicates",
"[",
"]",
"joiner",
",",
"predicateIndex",
"int",
",",
"selectPredicates",
"[",
"]",
"PredicateLinker",
",",
"functors",
"[",
"]",
"s... | // Recursive virtual row creation | [
"Recursive",
"virtual",
"row",
"creation"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/join.go#L164-L215 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.