ralsina/tartrazine
1
0
Fork 0
mirror of https://github.com/ralsina/tartrazine.git synced 2025-06-19 14:43:05 -03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #22 from mcarmonaa/shebang

Browse Source 
Added language detection by shebang functionality
This commit is contained in:
Santiago M. Mola
2017-05-04 15:58:31 +02:00
committed by GitHub
parent 4ed60ad05b f45efec5fb
commit 7920039c90
43 changed files with 974 additions and 969 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
cli/slinguist/main.go
View File

@ -5,6 +5,7 @@ import (
"flag" "flag"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"os" "os"
"path/filepath" "path/filepath"
@ -12,18 +13,20 @@ import (
) )
func main() { func main() {
flag.Usage = usage
flag.Parse() flag.Parse()
root, err := filepath.Abs(flag.Arg(0)) root, err := filepath.Abs(flag.Arg(0))
ifError(err) if err != nil {
log.Fatal(err)
if root == "" {
usage()
} }
errors := false
o := make(map[string][]string, 0) o := make(map[string][]string, 0)
err = filepath.Walk(root, func(path string, f os.FileInfo, err error) error { err = filepath.Walk(root, func(path string, f os.FileInfo, err error) error {
if err != nil { if err != nil {
return err errors = true
log.Println(err)
return filepath.SkipDir
} }
if slinguist.IsVendor(f.Name()) || slinguist.IsDotFile(f.Name()) { if slinguist.IsVendor(f.Name()) || slinguist.IsDotFile(f.Name()) {
@ -38,22 +41,36 @@ func main() {
return nil return nil
} }
l, safe := slinguist.GetLanguageByExtension(path) content, err := ioutil.ReadFile(path)
if !safe { if err != nil {
content, _ := ioutil.ReadFile(path) errors = true
l, safe = slinguist.GetLanguageByContent(path, content) log.Println(err)
return nil
}
l := slinguist.GetLanguage(path, content)
r, err := filepath.Rel(root, path)
if err != nil {
errors = true
log.Println(err)
return nil
} }
r, _ := filepath.Rel(root, path)
o[l] = append(o[l], r) o[l] = append(o[l], r)
return nil return nil
}) })
ifError(err) if err != nil {
log.Fatal(err)
}
js, _ := json.MarshalIndent(o, "", " ") js, _ := json.MarshalIndent(o, "", " ")
fmt.Printf("%s\n", js) fmt.Printf("%s\n", js)
if errors {
os.Exit(2)
}
} }
func usage() { func usage() {
@ -63,12 +80,4 @@ func usage() {
) )
flag.PrintDefaults() flag.PrintDefaults()
os.Exit(2)
}
func ifError(err error) {
if err != nil {
fmt.Fprintf(os.Stderr, err.Error())
os.Exit(2)
}
} }

4
common.go
View File

@ -36,6 +36,10 @@ func GetLanguageExtensions(language string) []string {
// GetLanguage return the Language for a given filename and file content. // GetLanguage return the Language for a given filename and file content.
func GetLanguage(filename string, content []byte) string { func GetLanguage(filename string, content []byte) string {
if lang, safe := GetLanguageByShebang(content); safe {
return lang
}
if lang, safe := GetLanguageByExtension(filename); safe { if lang, safe := GetLanguageByExtension(filename); safe {
return lang return lang
} }

2
content.go
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9 // Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9

2
documentation_matchers.go
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9 // Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9

2
internal/code-generator/assets/content.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

2
internal/code-generator/assets/documentation.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

11
internal/code-generator/assets/interpreters.go.tmpl Normal file
View File

@ -0,0 +1,11 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }}
var languagesByInterpreter = map[string][]string{
{{range $interpreter, $languages := . -}}
"{{ $interpreter }}": { {{- $languages | formatStringSlice -}} },
{{end -}}
}

2
internal/code-generator/assets/languages.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

14
internal/code-generator/assets/type.go.tmpl
View File

@ -1,19 +1,21 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}
type Type int type Type int
const ( const (
TypeUnknown Type = iota // Language's type. Either data, programming, markup, prose, or unknown.
TypeData Unknown Type = iota
TypeProgramming Data
TypeMarkup Programming
TypeProse Markup
Prose
) )
// GetLanguageType returns the given language's type.
func GetLanguageType(language string) (langType Type) { func GetLanguageType(language string) (langType Type) {
langType, _ = languagesType[language] langType, _ = languagesType[language]
return langType return langType

2
internal/code-generator/assets/vendor.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

216
internal/code-generator/generator/generator_test.go
View File

@ -12,18 +12,11 @@ import (
const ( const (
commitTest = "fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7" commitTest = "fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7"
// FromFile test
formatedLangGold = "test_files/formated_languages.gold"
formatedContentGold = "test_files/formated_content.gold"
formatedVendorGold = "test_files/formated_vendor.gold"
formatedDocumentationGold = "test_files/formated_documentation.gold"
formatedTypesGold = "test_files/formated_type.gold"
// Languages test // Languages test
ymlTestFile = "test_files/languages.test.yml" ymlTestFile = "test_files/languages.test.yml"
langGold = "test_files/languages.gold" langGold = "test_files/languages.gold"
languagesTestTmplPath = "test_files/languages.test.tmpl" languagesTestTmplPath = "test_files/languages.test.go.tmpl"
languagesTestTmplName = "languages.test.tmpl" languagesTestTmplName = "languages.test.go.tmpl"
// Heuristics test // Heuristics test
heuristicsTestFile = "test_files/heuristics.test.rb" heuristicsTestFile = "test_files/heuristics.test.rb"
@ -48,22 +41,31 @@ const (
typesGold = "test_files/type.gold" typesGold = "test_files/type.gold"
typesTestTmplPath = "test_files/type.test.go.tmpl" typesTestTmplPath = "test_files/type.test.go.tmpl"
typesTestTmplName = "type.test.go.tmpl" typesTestTmplName = "type.test.go.tmpl"
// Interpreters test
interpretersTestFile = "test_files/interpreters.test.yml"
interpretersGold = "test_files/interpreters.gold"
interpretersTestTmplPath = "test_files/interpreters.test.go.tmpl"
interpretersTestTmplName = "interpreters.test.go.tmpl"
) )
func TestFromFile(t *testing.T) { func TestFromFile(t *testing.T) {
goldLang, err := ioutil.ReadFile(formatedLangGold) goldLang, err := ioutil.ReadFile(langGold)
assert.NoError(t, err) assert.NoError(t, err)
goldContent, err := ioutil.ReadFile(formatedContentGold) goldContent, err := ioutil.ReadFile(contentGold)
assert.NoError(t, err) assert.NoError(t, err)
goldVendor, err := ioutil.ReadFile(formatedVendorGold) goldVendor, err := ioutil.ReadFile(vendorGold)
assert.NoError(t, err) assert.NoError(t, err)
goldDocumentation, err := ioutil.ReadFile(formatedDocumentationGold) goldDocumentation, err := ioutil.ReadFile(documentationGold)
assert.NoError(t, err) assert.NoError(t, err)
goldTypes, err := ioutil.ReadFile(formatedTypesGold) goldTypes, err := ioutil.ReadFile(typesGold)
assert.NoError(t, err)
goldInterpreters, err := ioutil.ReadFile(interpretersGold)
assert.NoError(t, err) assert.NoError(t, err)
outPathLang, err := ioutil.TempFile("/tmp", "generator-test-") outPathLang, err := ioutil.TempFile("/tmp", "generator-test-")
@ -86,6 +88,10 @@ func TestFromFile(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
defer os.Remove(outPathTypes.Name()) defer os.Remove(outPathTypes.Name())
outPathInterpreters, err := ioutil.TempFile("/tmp", "generator-test-")
assert.NoError(t, err)
defer os.Remove(outPathInterpreters.Name())
tests := []struct { tests := []struct {
name string name string
fileToParse string fileToParse string
@ -137,7 +143,7 @@ func TestFromFile(t *testing.T) {
wantOut: goldDocumentation, wantOut: goldDocumentation,
}, },
{ {
name: "tyTestFromFile_Types", name: "TestFromFile_Types",
fileToParse: typesTestFile, fileToParse: typesTestFile,
outPath: outPathTypes.Name(), outPath: outPathTypes.Name(),
tmplPath: typesTestTmplPath, tmplPath: typesTestTmplPath,
@ -146,6 +152,16 @@ func TestFromFile(t *testing.T) {
generate: Types, generate: Types,
wantOut: goldTypes, wantOut: goldTypes,
}, },
{
name: "TestFromFile_Interpreters",
fileToParse: interpretersTestFile,
outPath: outPathInterpreters.Name(),
tmplPath: interpretersTestTmplPath,
tmplName: interpretersTestTmplName,
commit: commitTest,
generate: Interpreters,
wantOut: goldInterpreters,
},
} }
for _, tt := range tests { for _, tt := range tests {
@ -158,173 +174,3 @@ func TestFromFile(t *testing.T) {
}) })
} }
} }
func TestLanguages(t *testing.T) {
gold, err := ioutil.ReadFile(langGold)
assert.NoError(t, err)
input, err := ioutil.ReadFile(ymlTestFile)
assert.NoError(t, err)
tests := []struct {
name string
input []byte
tmplPath string
tmplName string
commit string
wantOut []byte
}{
{
name: "TestLanguages",
input: input,
tmplPath: languagesTestTmplPath,
tmplName: languagesTestTmplName,
commit: commitTest,
wantOut: gold,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
out, err := Languages(tt.input, tt.tmplPath, tt.tmplName, tt.commit)
assert.NoError(t, err)
assert.EqualValues(t, tt.wantOut, out, fmt.Sprintf("Languages() = %v, want %v", string(out), string(tt.wantOut)))
})
}
}
func TestHeuristics(t *testing.T) {
gold, err := ioutil.ReadFile(contentGold)
assert.NoError(t, err)
input, err := ioutil.ReadFile(heuristicsTestFile)
assert.NoError(t, err)
tests := []struct {
name string
input []byte
tmplPath string
tmplName string
commit string
wantOut []byte
}{
{
name: "TestHeuristics",
input: input,
tmplPath: contentTestTmplPath,
tmplName: contentTestTmplName,
commit: commitTest,
wantOut: gold,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
out, err := Heuristics(tt.input, tt.tmplPath, tt.tmplName, tt.commit)
assert.NoError(t, err)
assert.EqualValues(t, tt.wantOut, out, fmt.Sprintf("Heuristics() = %v, want %v", string(out), string(tt.wantOut)))
})
}
}
func TestVendor(t *testing.T) {
gold, err := ioutil.ReadFile(vendorGold)
assert.NoError(t, err)
input, err := ioutil.ReadFile(vendorTestFile)
assert.NoError(t, err)
tests := []struct {
name string
input []byte
tmplPath string
tmplName string
commit string
wantOut []byte
}{
{
name: "TestVendor",
input: input,
tmplPath: vendorTestTmplPath,
tmplName: vendorTestTmplName,
commit: commitTest,
wantOut: gold,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
out, err := Vendor(tt.input, tt.tmplPath, tt.tmplName, tt.commit)
assert.NoError(t, err)
assert.EqualValues(t, tt.wantOut, out, fmt.Sprintf("Vendor() = %v, want %v", string(out), string(tt.wantOut)))
})
}
}
func TestDocumentation(t *testing.T) {
gold, err := ioutil.ReadFile(documentationGold)
assert.NoError(t, err)
input, err := ioutil.ReadFile(documentationTestFile)
assert.NoError(t, err)
tests := []struct {
name string
input []byte
tmplPath string
tmplName string
commit string
wantOut []byte
}{
{
name: "TestDocumentation",
input: input,
tmplPath: documentationTestTmplPath,
tmplName: documentationTestTmplName,
commit: commitTest,
wantOut: gold,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
out, err := Documentation(tt.input, tt.tmplPath, tt.tmplName, tt.commit)
assert.NoError(t, err)
assert.EqualValues(t, tt.wantOut, out, fmt.Sprintf("Documentation() = %v, want %v", string(out), string(tt.wantOut)))
})
}
}
func TestTypes(t *testing.T) {
gold, err := ioutil.ReadFile(typesGold)
assert.NoError(t, err)
input, err := ioutil.ReadFile(typesTestFile)
assert.NoError(t, err)
tests := []struct {
name string
input []byte
tmplPath string
tmplName string
commit string
wantOut []byte
}{
{
name: "TestTypes",
input: input,
tmplPath: typesTestTmplPath,
tmplName: typesTestTmplName,
commit: commitTest,
wantOut: gold,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
out, err := Types(tt.input, tt.tmplPath, tt.tmplName, tt.commit)
assert.NoError(t, err)
assert.EqualValues(t, tt.wantOut, out, fmt.Sprintf("Types() = %v, want %v", string(out), string(tt.wantOut)))
})
}
}

54
internal/code-generator/generator/interpreters.go Normal file
View File

@ -0,0 +1,54 @@
package generator
import (
"bytes"
"io"
"strings"
"text/template"
"gopkg.in/yaml.v2"
)
// Interpreters reads from buf and builds interpreters_map.go file from interpretersTmplPath.
func Interpreters(data []byte, interpretersTmplPath, interpretersTmplName, commit string) ([]byte, error) {
languages := make(map[string]*languageInfo)
if err := yaml.Unmarshal(data, &languages); err != nil {
return nil, err
}
orderedKeys := getAlphabeticalOrderedKeys(languages)
languagesByInterpreter := buildInterpreterLanguagesMap(languages, orderedKeys)
buf := &bytes.Buffer{}
if err := executeInterpretersTemplate(buf, languagesByInterpreter, interpretersTmplPath, interpretersTmplName, commit); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func buildInterpreterLanguagesMap(languages map[string]*languageInfo, orderedKeys []string) map[string][]string {
interpreterLangsMap := make(map[string][]string)
for _, lang := range orderedKeys {
langInfo := languages[lang]
for _, interpreter := range langInfo.Interpreters {
interpreterLangsMap[interpreter] = append(interpreterLangsMap[interpreter], lang)
}
}
return interpreterLangsMap
}
func executeInterpretersTemplate(out io.Writer, languagesByInterpreter map[string][]string, interpretersTmplPath, interpretersTmpl, commit string) error {
fmap := template.FuncMap{
"getCommit": func() string { return commit },
"formatStringSlice": func(slice []string) string { return `"` + strings.Join(slice, `","`) + `"` },
}
t := template.Must(template.New(interpretersTmpl).Funcs(fmap).ParseFiles(interpretersTmplPath))
if err := t.Execute(out, languagesByInterpreter); err != nil {
return err
}
return nil
}

25
internal/code-generator/generator/langs.go
View File

@ -3,6 +3,7 @@ package generator
import ( import (
"bytes" "bytes"
"io" "io"
"sort"
"strings" "strings"
"text/template" "text/template"
@ -11,10 +12,8 @@ import (
type languageInfo struct { type languageInfo struct {
Type string `yaml:"type,omitempty"` Type string `yaml:"type,omitempty"`
Aliases []string `yaml:"aliases,omitempty,flow"`
Extensions []string `yaml:"extensions,omitempty,flow"` Extensions []string `yaml:"extensions,omitempty,flow"`
Interpreters []string `yaml:"interpreters,omitempty,flow"` Interpreters []string `yaml:"interpreters,omitempty,flow"`
Group string `yaml:"group,omitempty"`
} }
// Languages reads from buf and builds languages.go file from languagesTmplPath. // Languages reads from buf and builds languages.go file from languagesTmplPath.
@ -24,11 +23,7 @@ func Languages(data []byte, languagesTmplPath, languagesTmplName, commit string)
return nil, err return nil, err
} }
orderedKeyList, err := getAlphabeticalOrderedKeys(data) orderedKeyList := getAlphabeticalOrderedKeys(languages)
if err != nil {
return nil, err
}
languagesByExtension := buildExtensionLanguageMap(languages, orderedKeyList) languagesByExtension := buildExtensionLanguageMap(languages, orderedKeyList)
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
@ -39,18 +34,14 @@ func Languages(data []byte, languagesTmplPath, languagesTmplName, commit string)
return buf.Bytes(), nil return buf.Bytes(), nil
} }
func getAlphabeticalOrderedKeys(data []byte) ([]string, error) { func getAlphabeticalOrderedKeys(languages map[string]*languageInfo) []string {
var yamlSlice yaml.MapSlice keyList := make([]string, 0)
if err := yaml.Unmarshal(data, &yamlSlice); err != nil { for lang := range languages {
return nil, err keyList = append(keyList, lang)
} }
orderedKeyList := make([]string, 0) sort.Strings(keyList)
for _, lang := range yamlSlice { return keyList
orderedKeyList = append(orderedKeyList, lang.Key.(string))
}
return orderedKeyList, nil
} }
func buildExtensionLanguageMap(languages map[string]*languageInfo, orderedKeyList []string) map[string][]string { func buildExtensionLanguageMap(languages map[string]*languageInfo, orderedKeyList []string) map[string][]string {

40
internal/code-generator/generator/test_files/content.gold
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7 // Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
@ -20,7 +20,7 @@ func GetLanguageByContent(filename string, content []byte) (lang string, safe bo
return GetLanguageByExtension(filename) return GetLanguageByExtension(filename)
} }
type languageMatcher func ([]byte) (string, bool) type languageMatcher func([]byte) (string, bool)
var matchers = map[string]languageMatcher{ var matchers = map[string]languageMatcher{
".asc": func(i []byte) (string, bool) { ".asc": func(i []byte) (string, bool) {
@ -31,14 +31,14 @@ var matchers = map[string]languageMatcher{
} else if asc_AGSScript_Matcher_0.Match(i) { } else if asc_AGSScript_Matcher_0.Match(i) {
return "AGS Script", true return "AGS Script", true
} }
return OtherLanguage, false return OtherLanguage, false
}, },
".ms": func(i []byte) (string, bool) { ".ms": func(i []byte) (string, bool) {
if ms_Groff_Matcher_0.Match(i) { if ms_Groff_Matcher_0.Match(i) {
return "Groff", true return "Groff", true
} }
return "MAXScript", true return "MAXScript", true
}, },
".mod": func(i []byte) (string, bool) { ".mod": func(i []byte) (string, bool) {
@ -47,7 +47,7 @@ var matchers = map[string]languageMatcher{
} else if mod_ModulaDash2_Matcher_0.Match(i) || mod_ModulaDash2_Matcher_1.Match(i) { } else if mod_ModulaDash2_Matcher_0.Match(i) || mod_ModulaDash2_Matcher_1.Match(i) {
return "Modula-2", true return "Modula-2", true
} }
return "Linux Kernel Module", false return "Linux Kernel Module", false
}, },
".pro": func(i []byte) (string, bool) { ".pro": func(i []byte) (string, bool) {
@ -60,22 +60,22 @@ var matchers = map[string]languageMatcher{
} else if pro_IDL_Matcher_0.Match(i) { } else if pro_IDL_Matcher_0.Match(i) {
return "IDL", true return "IDL", true
} }
return OtherLanguage, false return OtherLanguage, false
}, },
} }
var ( var (
asc_PublicKey_Matcher_0 = regexp.MustCompile(`(?m)^(----[- ]BEGIN|ssh-(rsa|dss)) `) asc_PublicKey_Matcher_0 = regexp.MustCompile(`(?m)^(----[- ]BEGIN|ssh-(rsa|dss)) `)
asc_AsciiDoc_Matcher_0 = regexp.MustCompile(`(?m)^[=-]+(\s|\n)|{{[A-Za-z]`) asc_AsciiDoc_Matcher_0 = regexp.MustCompile(`(?m)^[=-]+(\s|\n)|{{[A-Za-z]`)
asc_AGSScript_Matcher_0 = regexp.MustCompile(`(?m)^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])`) asc_AGSScript_Matcher_0 = regexp.MustCompile(`(?m)^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])`)
ms_Groff_Matcher_0 = regexp.MustCompile(`(?mi)^[.'][a-z][a-z](\s|$)`) ms_Groff_Matcher_0 = regexp.MustCompile(`(?mi)^[.'][a-z][a-z](\s|$)`)
mod_XML_Matcher_0 = regexp.MustCompile(`(?m)<!ENTITY `) mod_XML_Matcher_0 = regexp.MustCompile(`(?m)<!ENTITY `)
mod_ModulaDash2_Matcher_0 = regexp.MustCompile(`(?mi)^\s*MODULE [\w\.]+;`) mod_ModulaDash2_Matcher_0 = regexp.MustCompile(`(?mi)^\s*MODULE [\w\.]+;`)
mod_ModulaDash2_Matcher_1 = regexp.MustCompile(`(?mi)^\s*END [\w\.]+;`) mod_ModulaDash2_Matcher_1 = regexp.MustCompile(`(?mi)^\s*END [\w\.]+;`)
pro_Prolog_Matcher_0 = regexp.MustCompile(`(?m)^[^#]+:-`) pro_Prolog_Matcher_0 = regexp.MustCompile(`(?m)^[^#]+:-`)
pro_INI_Matcher_0 = regexp.MustCompile(`(?m)last_client=`) pro_INI_Matcher_0 = regexp.MustCompile(`(?m)last_client=`)
pro_QMake_Matcher_0 = regexp.MustCompile(`(?m)HEADERS`) pro_QMake_Matcher_0 = regexp.MustCompile(`(?m)HEADERS`)
pro_QMake_Matcher_1 = regexp.MustCompile(`(?m)SOURCES`) pro_QMake_Matcher_1 = regexp.MustCompile(`(?m)SOURCES`)
pro_IDL_Matcher_0 = regexp.MustCompile(`(?m)^\s*function[ \w,]+$`) pro_IDL_Matcher_0 = regexp.MustCompile(`(?m)^\s*function[ \w,]+$`)
) )

2
internal/code-generator/generator/test_files/content.test.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

4
internal/code-generator/generator/test_files/documentation.gold
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7 // Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
@ -22,4 +22,4 @@ var documentationMatchers = substring.Or(
substring.Regexp(`(^|/)README(\.|$)`), substring.Regexp(`(^|/)README(\.|$)`),
substring.Regexp(`(^|/)[Rr]eadme(\.|$)`), substring.Regexp(`(^|/)[Rr]eadme(\.|$)`),
substring.Regexp(`^[Ss]amples?/`), substring.Regexp(`^[Ss]amples?/`),
) )

2
internal/code-generator/generator/test_files/documentation.test.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

81
internal/code-generator/generator/test_files/formated_content.gold
View File

@ -1,81 +0,0 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
import (
"path/filepath"
"regexp"
"strings"
)
func GetLanguageByContent(filename string, content []byte) (lang string, safe bool) {
ext := strings.ToLower(filepath.Ext(filename))
if fnMatcher, ok := matchers[ext]; ok {
lang, safe = fnMatcher(content)
return
}
return GetLanguageByExtension(filename)
}
type languageMatcher func([]byte) (string, bool)
var matchers = map[string]languageMatcher{
".asc": func(i []byte) (string, bool) {
if asc_PublicKey_Matcher_0.Match(i) {
return "Public Key", true
} else if asc_AsciiDoc_Matcher_0.Match(i) {
return "AsciiDoc", true
} else if asc_AGSScript_Matcher_0.Match(i) {
return "AGS Script", true
}
return OtherLanguage, false
},
".ms": func(i []byte) (string, bool) {
if ms_Groff_Matcher_0.Match(i) {
return "Groff", true
}
return "MAXScript", true
},
".mod": func(i []byte) (string, bool) {
if mod_XML_Matcher_0.Match(i) {
return "XML", true
} else if mod_ModulaDash2_Matcher_0.Match(i) || mod_ModulaDash2_Matcher_1.Match(i) {
return "Modula-2", true
}
return "Linux Kernel Module", false
},
".pro": func(i []byte) (string, bool) {
if pro_Prolog_Matcher_0.Match(i) {
return "Prolog", true
} else if pro_INI_Matcher_0.Match(i) {
return "INI", true
} else if pro_QMake_Matcher_0.Match(i) && pro_QMake_Matcher_1.Match(i) {
return "QMake", true
} else if pro_IDL_Matcher_0.Match(i) {
return "IDL", true
}
return OtherLanguage, false
},
}
var (
asc_PublicKey_Matcher_0 = regexp.MustCompile(`(?m)^(----[- ]BEGIN|ssh-(rsa|dss)) `)
asc_AsciiDoc_Matcher_0 = regexp.MustCompile(`(?m)^[=-]+(\s|\n)|{{[A-Za-z]`)
asc_AGSScript_Matcher_0 = regexp.MustCompile(`(?m)^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])`)
ms_Groff_Matcher_0 = regexp.MustCompile(`(?mi)^[.'][a-z][a-z](\s|$)`)
mod_XML_Matcher_0 = regexp.MustCompile(`(?m)<!ENTITY `)
mod_ModulaDash2_Matcher_0 = regexp.MustCompile(`(?mi)^\s*MODULE [\w\.]+;`)
mod_ModulaDash2_Matcher_1 = regexp.MustCompile(`(?mi)^\s*END [\w\.]+;`)
pro_Prolog_Matcher_0 = regexp.MustCompile(`(?m)^[^#]+:-`)
pro_INI_Matcher_0 = regexp.MustCompile(`(?m)last_client=`)
pro_QMake_Matcher_0 = regexp.MustCompile(`(?m)HEADERS`)
pro_QMake_Matcher_1 = regexp.MustCompile(`(?m)SOURCES`)
pro_IDL_Matcher_0 = regexp.MustCompile(`(?m)^\s*function[ \w,]+$`)
)

25
internal/code-generator/generator/test_files/formated_documentation.gold
View File

@ -1,25 +0,0 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
import "gopkg.in/toqueteos/substring.v1"
var documentationMatchers = substring.Or(
substring.Regexp(`^[Dd]ocs?/`),
substring.Regexp(`(^|/)[Dd]ocumentation/`),
substring.Regexp(`(^|/)[Jj]avadoc/`),
substring.Regexp(`^[Mm]an/`),
substring.Regexp(`^[Ee]xamples/`),
substring.Regexp(`^[Dd]emos?/`),
substring.Regexp(`(^|/)CHANGE(S|LOG)?(\.|$)`),
substring.Regexp(`(^|/)CONTRIBUTING(\.|$)`),
substring.Regexp(`(^|/)COPYING(\.|$)`),
substring.Regexp(`(^|/)INSTALL(\.|$)`),
substring.Regexp(`(^|/)LICEN[CS]E(\.|$)`),
substring.Regexp(`(^|/)[Ll]icen[cs]e(\.|$)`),
substring.Regexp(`(^|/)README(\.|$)`),
substring.Regexp(`(^|/)[Rr]eadme(\.|$)`),
substring.Regexp(`^[Ss]amples?/`),
)

12
internal/code-generator/generator/test_files/formated_languages.gold
View File

@ -1,12 +0,0 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
var languagesByExtension = map[string][]string{
".abap": {"ABAP"},
".abnf": {"ABNF"},
".bsl": {"1C Enterprise"},
".os": {"1C Enterprise"},
}

27
internal/code-generator/generator/test_files/formated_type.gold
View File

@ -1,27 +0,0 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
type Type int
const (
TypeUnknown Type = iota
TypeData
TypeProgramming
TypeMarkup
TypeProse
)
func GetLanguageType(language string) (langType Type) {
langType, _ = languagesType[language]
return langType
}
var languagesType = map[string]Type{
"Scaml": TypeMarkup,
"Scheme": TypeProgramming,
"Scilab": TypeProgramming,
"Self": TypeProgramming,
}

24
internal/code-generator/generator/test_files/formated_vendor.gold
View File

@ -1,24 +0,0 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
import "gopkg.in/toqueteos/substring.v1"
var vendorMatchers = substring.Or(
substring.Regexp(`(^|/)cache/`),
substring.Regexp(`^[Dd]ependencies/`),
substring.Regexp(`(^|/)dist/`),
substring.Regexp(`^deps/`),
substring.Regexp(`^tools/`),
substring.Regexp(`(^|/)configure$`),
substring.Regexp(`(^|/)config.guess$`),
substring.Regexp(`(^|/)config.sub$`),
substring.Regexp(`(^|/)aclocal.m4`),
substring.Regexp(`(^|/)libtool.m4`),
substring.Regexp(`(^|/)ltoptions.m4`),
substring.Regexp(`(^|/)ltsugar.m4`),
substring.Regexp(`(^|/)ltversion.m4`),
substring.Regexp(`(^|/)lt~obsolete.m4`),
)

16
internal/code-generator/generator/test_files/interpreters.gold Normal file
View File

@ -0,0 +1,16 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
var languagesByInterpreter = map[string][]string{
"bash": {"Shell"},
"nush": {"Nu"},
"python": {"Python"},
"python2": {"Python"},
"python3": {"Python"},
"rc": {"Shell"},
"sh": {"Shell"},
"zsh": {"Shell"},
}

11
internal/code-generator/generator/test_files/interpreters.test.go.tmpl Normal file
View File

@ -0,0 +1,11 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }}
var languagesByInterpreter = map[string][]string{
{{range $interpreter, $languages := . -}}
"{{ $interpreter }}": { {{- $languages | formatStringSlice -}} },
{{end -}}
}

15
internal/code-generator/generator/test_files/interpreters.test.yml Normal file
View File

@ -0,0 +1,15 @@
---
Nu:
interpreters:
- nush
Shell:
interpreters:
- bash
- rc
- sh
- zsh
Python:
interpreters:
- python
- python2
- python3

12
internal/code-generator/generator/test_files/languages.gold
View File

@ -1,12 +1,12 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7 // Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
var languagesByExtension = map[string][]string{ var languagesByExtension = map[string][]string{
".abap": {"ABAP"}, ".abap": {"ABAP"},
".abnf": {"ABNF"}, ".abnf": {"ABNF"},
".bsl": {"1C Enterprise"}, ".bsl": {"1C Enterprise"},
".os": {"1C Enterprise"}, ".os": {"1C Enterprise"},
} }

2
internal/code-generator/generator/test_files/languages.test.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

2
internal/code-generator/generator/test_files/languages.test.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

13
internal/code-generator/generator/test_files/languages.test.yml
View File

@ -1,24 +1,11 @@
--- ---
1C Enterprise: 1C Enterprise:
type: programming
color: "#814CCC"
extensions: extensions:
- ".bsl" - ".bsl"
- ".os" - ".os"
tm_scope: source.bsl
ace_mode: text
language_id: 0
ABAP: ABAP:
type: programming
color: "#E8274B"
extensions: extensions:
- ".abap" - ".abap"
ace_mode: abap
language_id: 1
ABNF: ABNF:
type: data
ace_mode: text
extensions: extensions:
- ".abnf" - ".abnf"
tm_scope: source.abnf
language_id: 429

24
internal/code-generator/generator/test_files/type.gold
View File

@ -1,27 +1,29 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7 // Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
type Type int type Type int
const ( const (
TypeUnknown Type = iota // Language's type. Either data, programming, markup, prose, or unknown.
TypeData Unknown Type = iota
TypeProgramming Data
TypeMarkup Programming
TypeProse Markup
Prose
) )
// GetLanguageType returns the given language's type.
func GetLanguageType(language string) (langType Type) { func GetLanguageType(language string) (langType Type) {
langType, _ = languagesType[language] langType, _ = languagesType[language]
return langType return langType
} }
var languagesType = map[string]Type{ var languagesType = map[string]Type{
"Scaml": TypeMarkup, "Scaml": Markup,
"Scheme": TypeProgramming, "Scheme": Programming,
"Scilab": TypeProgramming, "Scilab": Programming,
"Self": TypeProgramming, "Self": Programming,
} }

14
internal/code-generator/generator/test_files/type.test.go.tmpl
View File

@ -1,19 +1,21 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}
type Type int type Type int
const ( const (
TypeUnknown Type = iota // Language's type. Either data, programming, markup, prose, or unknown.
TypeData Unknown Type = iota
TypeProgramming Data
TypeMarkup Programming
TypeProse Markup
Prose
) )
// GetLanguageType returns the given language's type.
func GetLanguageType(language string) (langType Type) { func GetLanguageType(language string) (langType Type) {
langType, _ = languagesType[language] langType, _ = languagesType[language]
return langType return langType

37
internal/code-generator/generator/test_files/type.test.yml
View File

@ -1,46 +1,11 @@
--- ---
Scaml: Scaml:
group: HTML
type: markup type: markup
extensions:
- ".scaml"
tm_scope: source.scaml
ace_mode: text
language_id: 342
Scheme: Scheme:
type: programming type: programming
color: "#1e4aec"
extensions:
- ".scm"
- ".sld"
- ".sls"
- ".sps"
- ".ss"
interpreters:
- guile
- bigloo
- chicken
- csi
- gosh
- r6rs
ace_mode: scheme
codemirror_mode: scheme
codemirror_mime_type: text/x-scheme
language_id: 343
Scilab: Scilab:
type: programming type: programming
extensions:
- ".sci"
- ".sce"
- ".tst"
ace_mode: text
language_id: 344
Self: Self:
type: programming type: programming
color: "#0579aa"
extensions:
- ".self"
tm_scope: none
ace_mode: text
language_id: 345

4
internal/code-generator/generator/test_files/vendor.gold
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7 // Extracted from github/linguist commit: fe8b44ab8a225b1ffa75b983b916ea22fee5b6f7
@ -21,4 +21,4 @@ var vendorMatchers = substring.Or(
substring.Regexp(`(^|/)ltsugar.m4`), substring.Regexp(`(^|/)ltsugar.m4`),
substring.Regexp(`(^|/)ltversion.m4`), substring.Regexp(`(^|/)ltversion.m4`),
substring.Regexp(`(^|/)lt~obsolete.m4`), substring.Regexp(`(^|/)lt~obsolete.m4`),
) )

2
internal/code-generator/generator/test_files/vendor.test.go.tmpl
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: {{ getCommit }} // Extracted from github/linguist commit: {{ getCommit }}

8
internal/code-generator/generator/types.go
View File

@ -9,10 +9,10 @@ import (
) )
var typeToTypeConst = map[string]string{ var typeToTypeConst = map[string]string{
"data": "TypeData", "data": "Data",
"programming": "TypeProgramming", "programming": "Programming",
"markup": "TypeMarkup", "markup": "Markup",
"prose": "TypeProse", "prose": "Prose",
} }
// Types reads from buf and builds type.go file from typeTmplPath. // Types reads from buf and builds type.go file from typeTmplPath.

6
internal/code-generator/main.go
View File

@ -37,6 +37,11 @@ const (
typeTmplPath = "internal/code-generator/assets/type.go.tmpl" typeTmplPath = "internal/code-generator/assets/type.go.tmpl"
typeTmpl = "type.go.tmpl" typeTmpl = "type.go.tmpl"
// interpreters_map.go generation
interpretersFile = "interpreters_map.go"
interpretersTmplPath = "internal/code-generator/assets/interpreters.go.tmpl"
interpretersTmpl = "interpreters.go.tmpl"
commitPath = ".git/refs/heads/master" commitPath = ".git/refs/heads/master"
) )
@ -61,6 +66,7 @@ func main() {
&generatorArgs{vendorYAML, vendorFile, vendorTmplPath, vendorTmpl, commit, generator.Vendor}, &generatorArgs{vendorYAML, vendorFile, vendorTmplPath, vendorTmpl, commit, generator.Vendor},
&generatorArgs{documentationYAML, documentationFile, documentationTmplPath, documentationTmpl, commit, generator.Documentation}, &generatorArgs{documentationYAML, documentationFile, documentationTmplPath, documentationTmpl, commit, generator.Documentation},
&generatorArgs{languagesYAML, typeFile, typeTmplPath, typeTmpl, commit, generator.Types}, &generatorArgs{languagesYAML, typeFile, typeTmplPath, typeTmpl, commit, generator.Types},
&generatorArgs{languagesYAML, interpretersFile, interpretersTmplPath, interpretersTmpl, commit, generator.Interpreters},
} }
for _, args := range argsList { for _, args := range argsList {

98
interpreters_map.go Normal file
View File

@ -0,0 +1,98 @@
package slinguist
// CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9
var languagesByInterpreter = map[string][]string{
"Rscript": {"R"},
"apl": {"APL"},
"aplx": {"APL"},
"awk": {"Awk"},
"bash": {"Shell"},
"bigloo": {"Scheme"},
"boolector": {"SMT"},
"ccl": {"Common Lisp"},
"chicken": {"Scheme"},
"clisp": {"Common Lisp"},
"coffee": {"CoffeeScript"},
"crystal": {"Crystal"},
"csi": {"Scheme"},
"cvc4": {"SMT"},
"dart": {"Dart"},
"dtrace": {"DTrace"},
"dyalog": {"APL"},
"ecl": {"Common Lisp"},
"elixir": {"Elixir"},
"escript": {"Erlang"},
"fish": {"fish"},
"gawk": {"Awk"},
"gn": {"GN"},
"gnuplot": {"Gnuplot"},
"gosh": {"Scheme"},
"groovy": {"Groovy"},
"guile": {"Scheme"},
"instantfpc": {"Pascal"},
"io": {"Io"},
"ioke": {"Ioke"},
"jconsole": {"J"},
"jruby": {"Ruby"},
"julia": {"Julia"},
"lisp": {"Common Lisp"},
"lsl": {"LSL"},
"lua": {"Lua", "Terra"},
"macruby": {"Ruby"},
"make": {"Makefile"},
"mathsat5": {"SMT"},
"mawk": {"Awk"},
"mmi": {"Mercury"},
"moon": {"MoonScript"},
"nawk": {"Awk"},
"newlisp": {"NewLisp"},
"node": {"JavaScript"},
"nush": {"Nu"},
"ocaml": {"OCaml", "Reason"},
"ocamlrun": {"OCaml"},
"ocamlscript": {"OCaml"},
"openrc-run": {"OpenRC runscript"},
"opensmt": {"SMT"},
"osascript": {"AppleScript"},
"parrot": {"Parrot Assembly", "Parrot Internal Representation"},
"perl": {"Perl"},
"perl6": {"Perl6"},
"php": {"PHP"},
"picolisp": {"PicoLisp"},
"pike": {"Pike"},
"pil": {"PicoLisp"},
"python": {"Python"},
"python2": {"Python"},
"python3": {"Python"},
"qmake": {"QMake"},
"r6rs": {"Scheme"},
"racket": {"Racket"},
"rake": {"Ruby"},
"rbx": {"Ruby"},
"rc": {"Shell"},
"regina": {"REXX"},
"rexx": {"REXX"},
"ruby": {"Ruby"},
"rune": {"E"},
"runhaskell": {"Haskell"},
"sbcl": {"Common Lisp"},
"scala": {"Scala"},
"sclang": {"SuperCollider"},
"scsynth": {"SuperCollider"},
"sh": {"Shell"},
"smt-rat": {"SMT"},
"smtinterpol": {"SMT"},
"stp": {"SMT"},
"swipl": {"Prolog"},
"tcc": {"C"},
"tclsh": {"Tcl"},
"verit": {"SMT"},
"wish": {"Tcl"},
"yap": {"Prolog"},
"yices2": {"SMT"},
"z3": {"SMT"},
"zsh": {"Shell"},
}

2
languages.go
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9 // Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9

93
shebang.go Normal file
View File

@ -0,0 +1,93 @@
package slinguist
import (
"bufio"
"bytes"
"regexp"
"strings"
)
var (
shebangExecHack = regexp.MustCompile(`exec (\w+).+\$0.+\$@`)
pythonVersion = regexp.MustCompile(`python\d\.\d+`)
)
// GetLanguageByShebang returns the language of the given content looking for the shebang line,
// and safe to indicate the sureness of returned language.
func GetLanguageByShebang(content []byte) (lang string, safe bool) {
interpreter := getInterpreter(content)
lang = OtherLanguage
if langs, ok := languagesByInterpreter[interpreter]; ok {
lang = langs[0]
safe = len(langs) == 1
}
return
}
func getInterpreter(data []byte) (interpreter string) {
line := getFirstLine(data)
if !hasShebang(line) {
return ""
}
// skip shebang
line = bytes.TrimSpace(line[2:])
splitted := bytes.Fields(line)
if bytes.Contains(splitted[0], []byte("env")) {
if len(splitted) > 1 {
interpreter = string(splitted[1])
}
} else {
splittedPath := bytes.Split(splitted[0], []byte{'/'})
interpreter = string(splittedPath[len(splittedPath)-1])
}
if interpreter == "sh" {
interpreter = lookForMultilineExec(data)
}
if pythonVersion.MatchString(interpreter) {
interpreter = interpreter[:strings.Index(interpreter, `.`)]
}
return
}
func getFirstLine(data []byte) []byte {
buf := bufio.NewScanner(bytes.NewReader(data))
buf.Scan()
line := buf.Bytes()
if err := buf.Err(); err != nil {
return nil
}
return line
}
func hasShebang(line []byte) bool {
shebang := []byte{'#', '!'}
return bytes.HasPrefix(line, shebang)
}
func lookForMultilineExec(data []byte) string {
const magicNumOfLines = 5
interpreter := "sh"
buf := bufio.NewScanner(bytes.NewReader(data))
for i := 0; i < magicNumOfLines && buf.Scan(); i++ {
line := buf.Bytes()
if shebangExecHack.Match(line) {
interpreter = shebangExecHack.FindStringSubmatch(string(line))[1]
break
}
}
if err := buf.Err(); err != nil {
return interpreter
}
return interpreter
}

60
shebang_test.go Normal file
View File

@ -0,0 +1,60 @@
package slinguist
import . "gopkg.in/check.v1"
const (
multilineExecHack = `#!/bin/sh
# Next line is comment in Tcl, but not in sh... \
exec tclsh "$0" ${1+"$@"}`
multilineNoExecHack = `#!/bin/sh
#<<<#
echo "A shell script in a zkl program ($0)"
echo "Now run zkl <this file> with Hello World as args"
zkl $0 Hello World!
exit
#<<<#
println("The shell script says ",vm.arglist.concat(" "));`
)
func (s *TSuite) TestGetLanguageByShebang(c *C) {
lang, safe := GetLanguageByShebang([]byte(`#!/unknown/interpreter`))
c.Assert(lang, Equals, OtherLanguage)
c.Assert(safe, Equals, false)
lang, safe = GetLanguageByShebang([]byte(`no shebang`))
c.Assert(lang, Equals, OtherLanguage)
c.Assert(safe, Equals, false)
lang, safe = GetLanguageByShebang([]byte(`#!/usr/bin/env`))
c.Assert(lang, Equals, OtherLanguage)
c.Assert(safe, Equals, false)
lang, safe = GetLanguageByShebang([]byte(`#!/usr/bin/python -tt`))
c.Assert(lang, Equals, "Python")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(`#!/usr/bin/env python2.6`))
c.Assert(lang, Equals, "Python")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(`#!/usr/bin/env perl`))
c.Assert(lang, Equals, "Perl")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(`#! /bin/sh`))
c.Assert(lang, Equals, "Shell")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(`#!bash`))
c.Assert(lang, Equals, "Shell")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(multilineExecHack))
c.Assert(lang, Equals, "Tcl")
c.Assert(safe, Equals, true)
lang, safe = GetLanguageByShebang([]byte(multilineNoExecHack))
c.Assert(lang, Equals, "Shell")
c.Assert(safe, Equals, true)
}

902
type.go
View File

@ -1,467 +1,469 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9 // Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9
type Type int type Type int
const ( const (
TypeUnknown Type = iota // Language's type. Either data, programming, markup, prose, or unknown.
TypeData Unknown Type = iota
TypeProgramming Data
TypeMarkup Programming
TypeProse Markup
Prose
) )
// GetLanguageType returns the given language's type.
func GetLanguageType(language string) (langType Type) { func GetLanguageType(language string) (langType Type) {
langType, _ = languagesType[language] langType, _ = languagesType[language]
return langType return langType
} }
var languagesType = map[string]Type{ var languagesType = map[string]Type{
"1C Enterprise": TypeProgramming, "1C Enterprise": Programming,
"ABAP": TypeProgramming, "ABAP": Programming,
"ABNF": TypeData, "ABNF": Data,
"AGS Script": TypeProgramming, "AGS Script": Programming,
"AMPL": TypeProgramming, "AMPL": Programming,
"ANTLR": TypeProgramming, "ANTLR": Programming,
"API Blueprint": TypeMarkup, "API Blueprint": Markup,
"APL": TypeProgramming, "APL": Programming,
"ASN.1": TypeData, "ASN.1": Data,
"ASP": TypeProgramming, "ASP": Programming,
"ATS": TypeProgramming, "ATS": Programming,
"ActionScript": TypeProgramming, "ActionScript": Programming,
"Ada": TypeProgramming, "Ada": Programming,
"Agda": TypeProgramming, "Agda": Programming,
"Alloy": TypeProgramming, "Alloy": Programming,
"Alpine Abuild": TypeProgramming, "Alpine Abuild": Programming,
"Ant Build System": TypeData, "Ant Build System": Data,
"ApacheConf": TypeMarkup, "ApacheConf": Markup,
"Apex": TypeProgramming, "Apex": Programming,
"Apollo Guidance Computer": TypeProgramming, "Apollo Guidance Computer": Programming,
"AppleScript": TypeProgramming, "AppleScript": Programming,
"Arc": TypeProgramming, "Arc": Programming,
"Arduino": TypeProgramming, "Arduino": Programming,
"AsciiDoc": TypeProse, "AsciiDoc": Prose,
"AspectJ": TypeProgramming, "AspectJ": Programming,
"Assembly": TypeProgramming, "Assembly": Programming,
"Augeas": TypeProgramming, "Augeas": Programming,
"AutoHotkey": TypeProgramming, "AutoHotkey": Programming,
"AutoIt": TypeProgramming, "AutoIt": Programming,
"Awk": TypeProgramming, "Awk": Programming,
"Batchfile": TypeProgramming, "Batchfile": Programming,
"Befunge": TypeProgramming, "Befunge": Programming,
"Bison": TypeProgramming, "Bison": Programming,
"BitBake": TypeProgramming, "BitBake": Programming,
"Blade": TypeMarkup, "Blade": Markup,
"BlitzBasic": TypeProgramming, "BlitzBasic": Programming,
"BlitzMax": TypeProgramming, "BlitzMax": Programming,
"Bluespec": TypeProgramming, "Bluespec": Programming,
"Boo": TypeProgramming, "Boo": Programming,
"Brainfuck": TypeProgramming, "Brainfuck": Programming,
"Brightscript": TypeProgramming, "Brightscript": Programming,
"Bro": TypeProgramming, "Bro": Programming,
"C": TypeProgramming, "C": Programming,
"C#": TypeProgramming, "C#": Programming,
"C++": TypeProgramming, "C++": Programming,
"C-ObjDump": TypeData, "C-ObjDump": Data,
"C2hs Haskell": TypeProgramming, "C2hs Haskell": Programming,
"CLIPS": TypeProgramming, "CLIPS": Programming,
"CMake": TypeProgramming, "CMake": Programming,
"COBOL": TypeProgramming, "COBOL": Programming,
"COLLADA": TypeData, "COLLADA": Data,
"CSON": TypeData, "CSON": Data,
"CSS": TypeMarkup, "CSS": Markup,
"CSV": TypeData, "CSV": Data,
"Cap'n Proto": TypeProgramming, "Cap'n Proto": Programming,
"CartoCSS": TypeProgramming, "CartoCSS": Programming,
"Ceylon": TypeProgramming, "Ceylon": Programming,
"Chapel": TypeProgramming, "Chapel": Programming,
"Charity": TypeProgramming, "Charity": Programming,
"ChucK": TypeProgramming, "ChucK": Programming,
"Cirru": TypeProgramming, "Cirru": Programming,
"Clarion": TypeProgramming, "Clarion": Programming,
"Clean": TypeProgramming, "Clean": Programming,
"Click": TypeProgramming, "Click": Programming,
"Clojure": TypeProgramming, "Clojure": Programming,
"CoffeeScript": TypeProgramming, "CoffeeScript": Programming,
"ColdFusion": TypeProgramming, "ColdFusion": Programming,
"ColdFusion CFC": TypeProgramming, "ColdFusion CFC": Programming,
"Common Lisp": TypeProgramming, "Common Lisp": Programming,
"Component Pascal": TypeProgramming, "Component Pascal": Programming,
"Cool": TypeProgramming, "Cool": Programming,
"Coq": TypeProgramming, "Coq": Programming,
"Cpp-ObjDump": TypeData, "Cpp-ObjDump": Data,
"Creole": TypeProse, "Creole": Prose,
"Crystal": TypeProgramming, "Crystal": Programming,
"Csound": TypeProgramming, "Csound": Programming,
"Csound Document": TypeProgramming, "Csound Document": Programming,
"Csound Score": TypeProgramming, "Csound Score": Programming,
"Cuda": TypeProgramming, "Cuda": Programming,
"Cycript": TypeProgramming, "Cycript": Programming,
"Cython": TypeProgramming, "Cython": Programming,
"D": TypeProgramming, "D": Programming,
"D-ObjDump": TypeData, "D-ObjDump": Data,
"DIGITAL Command Language": TypeProgramming, "DIGITAL Command Language": Programming,
"DM": TypeProgramming, "DM": Programming,
"DNS Zone": TypeData, "DNS Zone": Data,
"DTrace": TypeProgramming, "DTrace": Programming,
"Darcs Patch": TypeData, "Darcs Patch": Data,
"Dart": TypeProgramming, "Dart": Programming,
"Diff": TypeData, "Diff": Data,
"Dockerfile": TypeData, "Dockerfile": Data,
"Dogescript": TypeProgramming, "Dogescript": Programming,
"Dylan": TypeProgramming, "Dylan": Programming,
"E": TypeProgramming, "E": Programming,
"EBNF": TypeData, "EBNF": Data,
"ECL": TypeProgramming, "ECL": Programming,
"ECLiPSe": TypeProgramming, "ECLiPSe": Programming,
"EJS": TypeMarkup, "EJS": Markup,
"EQ": TypeProgramming, "EQ": Programming,
"Eagle": TypeMarkup, "Eagle": Markup,
"Ecere Projects": TypeData, "Ecere Projects": Data,
"Eiffel": TypeProgramming, "Eiffel": Programming,
"Elixir": TypeProgramming, "Elixir": Programming,
"Elm": TypeProgramming, "Elm": Programming,
"Emacs Lisp": TypeProgramming, "Emacs Lisp": Programming,
"EmberScript": TypeProgramming, "EmberScript": Programming,
"Erlang": TypeProgramming, "Erlang": Programming,
"F#": TypeProgramming, "F#": Programming,
"FLUX": TypeProgramming, "FLUX": Programming,
"Factor": TypeProgramming, "Factor": Programming,
"Fancy": TypeProgramming, "Fancy": Programming,
"Fantom": TypeProgramming, "Fantom": Programming,
"Filebench WML": TypeProgramming, "Filebench WML": Programming,
"Filterscript": TypeProgramming, "Filterscript": Programming,
"Formatted": TypeData, "Formatted": Data,
"Forth": TypeProgramming, "Forth": Programming,
"Fortran": TypeProgramming, "Fortran": Programming,
"FreeMarker": TypeProgramming, "FreeMarker": Programming,
"Frege": TypeProgramming, "Frege": Programming,
"G-code": TypeData, "G-code": Data,
"GAMS": TypeProgramming, "GAMS": Programming,
"GAP": TypeProgramming, "GAP": Programming,
"GCC Machine Description": TypeProgramming, "GCC Machine Description": Programming,
"GDB": TypeProgramming, "GDB": Programming,
"GDScript": TypeProgramming, "GDScript": Programming,
"GLSL": TypeProgramming, "GLSL": Programming,
"GN": TypeData, "GN": Data,
"Game Maker Language": TypeProgramming, "Game Maker Language": Programming,
"Genie": TypeProgramming, "Genie": Programming,
"Genshi": TypeProgramming, "Genshi": Programming,
"Gentoo Ebuild": TypeProgramming, "Gentoo Ebuild": Programming,
"Gentoo Eclass": TypeProgramming, "Gentoo Eclass": Programming,
"Gettext Catalog": TypeProse, "Gettext Catalog": Prose,
"Gherkin": TypeProgramming, "Gherkin": Programming,
"Glyph": TypeProgramming, "Glyph": Programming,
"Gnuplot": TypeProgramming, "Gnuplot": Programming,
"Go": TypeProgramming, "Go": Programming,
"Golo": TypeProgramming, "Golo": Programming,
"Gosu": TypeProgramming, "Gosu": Programming,
"Grace": TypeProgramming, "Grace": Programming,
"Gradle": TypeData, "Gradle": Data,
"Grammatical Framework": TypeProgramming, "Grammatical Framework": Programming,
"Graph Modeling Language": TypeData, "Graph Modeling Language": Data,
"GraphQL": TypeData, "GraphQL": Data,
"Graphviz (DOT)": TypeData, "Graphviz (DOT)": Data,
"Groovy": TypeProgramming, "Groovy": Programming,
"Groovy Server Pages": TypeProgramming, "Groovy Server Pages": Programming,
"HCL": TypeProgramming, "HCL": Programming,
"HLSL": TypeProgramming, "HLSL": Programming,
"HTML": TypeMarkup, "HTML": Markup,
"HTML+Django": TypeMarkup, "HTML+Django": Markup,
"HTML+ECR": TypeMarkup, "HTML+ECR": Markup,
"HTML+EEX": TypeMarkup, "HTML+EEX": Markup,
"HTML+ERB": TypeMarkup, "HTML+ERB": Markup,
"HTML+PHP": TypeMarkup, "HTML+PHP": Markup,
"HTTP": TypeData, "HTTP": Data,
"Hack": TypeProgramming, "Hack": Programming,
"Haml": TypeMarkup, "Haml": Markup,
"Handlebars": TypeMarkup, "Handlebars": Markup,
"Harbour": TypeProgramming, "Harbour": Programming,
"Haskell": TypeProgramming, "Haskell": Programming,
"Haxe": TypeProgramming, "Haxe": Programming,
"Hy": TypeProgramming, "Hy": Programming,
"HyPhy": TypeProgramming, "HyPhy": Programming,
"IDL": TypeProgramming, "IDL": Programming,
"IGOR Pro": TypeProgramming, "IGOR Pro": Programming,
"INI": TypeData, "INI": Data,
"IRC log": TypeData, "IRC log": Data,
"Idris": TypeProgramming, "Idris": Programming,
"Inform 7": TypeProgramming, "Inform 7": Programming,
"Inno Setup": TypeProgramming, "Inno Setup": Programming,
"Io": TypeProgramming, "Io": Programming,
"Ioke": TypeProgramming, "Ioke": Programming,
"Isabelle": TypeProgramming, "Isabelle": Programming,
"Isabelle ROOT": TypeProgramming, "Isabelle ROOT": Programming,
"J": TypeProgramming, "J": Programming,
"JFlex": TypeProgramming, "JFlex": Programming,
"JSON": TypeData, "JSON": Data,
"JSON5": TypeData, "JSON5": Data,
"JSONLD": TypeData, "JSONLD": Data,
"JSONiq": TypeProgramming, "JSONiq": Programming,
"JSX": TypeProgramming, "JSX": Programming,
"Jasmin": TypeProgramming, "Jasmin": Programming,
"Java": TypeProgramming, "Java": Programming,
"Java Server Pages": TypeProgramming, "Java Server Pages": Programming,
"JavaScript": TypeProgramming, "JavaScript": Programming,
"Jison": TypeProgramming, "Jison": Programming,
"Jison Lex": TypeProgramming, "Jison Lex": Programming,
"Julia": TypeProgramming, "Julia": Programming,
"Jupyter Notebook": TypeMarkup, "Jupyter Notebook": Markup,
"KRL": TypeProgramming, "KRL": Programming,
"KiCad": TypeProgramming, "KiCad": Programming,
"Kit": TypeMarkup, "Kit": Markup,
"Kotlin": TypeProgramming, "Kotlin": Programming,
"LFE": TypeProgramming, "LFE": Programming,
"LLVM": TypeProgramming, "LLVM": Programming,
"LOLCODE": TypeProgramming, "LOLCODE": Programming,
"LSL": TypeProgramming, "LSL": Programming,
"LabVIEW": TypeProgramming, "LabVIEW": Programming,
"Lasso": TypeProgramming, "Lasso": Programming,
"Latte": TypeMarkup, "Latte": Markup,
"Lean": TypeProgramming, "Lean": Programming,
"Less": TypeMarkup, "Less": Markup,
"Lex": TypeProgramming, "Lex": Programming,
"LilyPond": TypeProgramming, "LilyPond": Programming,
"Limbo": TypeProgramming, "Limbo": Programming,
"Linker Script": TypeData, "Linker Script": Data,
"Linux Kernel Module": TypeData, "Linux Kernel Module": Data,
"Liquid": TypeMarkup, "Liquid": Markup,
"Literate Agda": TypeProgramming, "Literate Agda": Programming,
"Literate CoffeeScript": TypeProgramming, "Literate CoffeeScript": Programming,
"Literate Haskell": TypeProgramming, "Literate Haskell": Programming,
"LiveScript": TypeProgramming, "LiveScript": Programming,
"Logos": TypeProgramming, "Logos": Programming,
"Logtalk": TypeProgramming, "Logtalk": Programming,
"LookML": TypeProgramming, "LookML": Programming,
"LoomScript": TypeProgramming, "LoomScript": Programming,
"Lua": TypeProgramming, "Lua": Programming,
"M": TypeProgramming, "M": Programming,
"M4": TypeProgramming, "M4": Programming,
"M4Sugar": TypeProgramming, "M4Sugar": Programming,
"MAXScript": TypeProgramming, "MAXScript": Programming,
"MQL4": TypeProgramming, "MQL4": Programming,
"MQL5": TypeProgramming, "MQL5": Programming,
"MTML": TypeMarkup, "MTML": Markup,
"MUF": TypeProgramming, "MUF": Programming,
"Makefile": TypeProgramming, "Makefile": Programming,
"Mako": TypeProgramming, "Mako": Programming,
"Markdown": TypeProse, "Markdown": Prose,
"Marko": TypeMarkup, "Marko": Markup,
"Mask": TypeMarkup, "Mask": Markup,
"Mathematica": TypeProgramming, "Mathematica": Programming,
"Matlab": TypeProgramming, "Matlab": Programming,
"Maven POM": TypeData, "Maven POM": Data,
"Max": TypeProgramming, "Max": Programming,
"MediaWiki": TypeProse, "MediaWiki": Prose,
"Mercury": TypeProgramming, "Mercury": Programming,
"Meson": TypeProgramming, "Meson": Programming,
"Metal": TypeProgramming, "Metal": Programming,
"MiniD": TypeProgramming, "MiniD": Programming,
"Mirah": TypeProgramming, "Mirah": Programming,
"Modelica": TypeProgramming, "Modelica": Programming,
"Modula-2": TypeProgramming, "Modula-2": Programming,
"Module Management System": TypeProgramming, "Module Management System": Programming,
"Monkey": TypeProgramming, "Monkey": Programming,
"Moocode": TypeProgramming, "Moocode": Programming,
"MoonScript": TypeProgramming, "MoonScript": Programming,
"Myghty": TypeProgramming, "Myghty": Programming,
"NCL": TypeProgramming, "NCL": Programming,
"NL": TypeData, "NL": Data,
"NSIS": TypeProgramming, "NSIS": Programming,
"Nemerle": TypeProgramming, "Nemerle": Programming,
"NetLinx": TypeProgramming, "NetLinx": Programming,
"NetLinx+ERB": TypeProgramming, "NetLinx+ERB": Programming,
"NetLogo": TypeProgramming, "NetLogo": Programming,
"NewLisp": TypeProgramming, "NewLisp": Programming,
"Nginx": TypeMarkup, "Nginx": Markup,
"Nim": TypeProgramming, "Nim": Programming,
"Ninja": TypeData, "Ninja": Data,
"Nit": TypeProgramming, "Nit": Programming,
"Nix": TypeProgramming, "Nix": Programming,
"Nu": TypeProgramming, "Nu": Programming,
"NumPy": TypeProgramming, "NumPy": Programming,
"OCaml": TypeProgramming, "OCaml": Programming,
"ObjDump": TypeData, "ObjDump": Data,
"Objective-C": TypeProgramming, "Objective-C": Programming,
"Objective-C++": TypeProgramming, "Objective-C++": Programming,
"Objective-J": TypeProgramming, "Objective-J": Programming,
"Omgrofl": TypeProgramming, "Omgrofl": Programming,
"Opa": TypeProgramming, "Opa": Programming,
"Opal": TypeProgramming, "Opal": Programming,
"OpenCL": TypeProgramming, "OpenCL": Programming,
"OpenEdge ABL": TypeProgramming, "OpenEdge ABL": Programming,
"OpenRC runscript": TypeProgramming, "OpenRC runscript": Programming,
"OpenSCAD": TypeProgramming, "OpenSCAD": Programming,
"OpenType Feature File": TypeData, "OpenType Feature File": Data,
"Org": TypeProse, "Org": Prose,
"Ox": TypeProgramming, "Ox": Programming,
"Oxygene": TypeProgramming, "Oxygene": Programming,
"Oz": TypeProgramming, "Oz": Programming,
"P4": TypeProgramming, "P4": Programming,
"PAWN": TypeProgramming, "PAWN": Programming,
"PHP": TypeProgramming, "PHP": Programming,
"PLSQL": TypeProgramming, "PLSQL": Programming,
"PLpgSQL": TypeProgramming, "PLpgSQL": Programming,
"POV-Ray SDL": TypeProgramming, "POV-Ray SDL": Programming,
"Pan": TypeProgramming, "Pan": Programming,
"Papyrus": TypeProgramming, "Papyrus": Programming,
"Parrot": TypeProgramming, "Parrot": Programming,
"Parrot Assembly": TypeProgramming, "Parrot Assembly": Programming,
"Parrot Internal Representation": TypeProgramming, "Parrot Internal Representation": Programming,
"Pascal": TypeProgramming, "Pascal": Programming,
"Perl": TypeProgramming, "Perl": Programming,
"Perl6": TypeProgramming, "Perl6": Programming,
"Pic": TypeMarkup, "Pic": Markup,
"Pickle": TypeData, "Pickle": Data,
"PicoLisp": TypeProgramming, "PicoLisp": Programming,
"PigLatin": TypeProgramming, "PigLatin": Programming,
"Pike": TypeProgramming, "Pike": Programming,
"Pod": TypeProse, "Pod": Prose,
"PogoScript": TypeProgramming, "PogoScript": Programming,
"Pony": TypeProgramming, "Pony": Programming,
"PostScript": TypeMarkup, "PostScript": Markup,
"PowerBuilder": TypeProgramming, "PowerBuilder": Programming,
"PowerShell": TypeProgramming, "PowerShell": Programming,
"Processing": TypeProgramming, "Processing": Programming,
"Prolog": TypeProgramming, "Prolog": Programming,
"Propeller Spin": TypeProgramming, "Propeller Spin": Programming,
"Protocol Buffer": TypeMarkup, "Protocol Buffer": Markup,
"Public Key": TypeData, "Public Key": Data,
"Pug": TypeMarkup, "Pug": Markup,
"Puppet": TypeProgramming, "Puppet": Programming,
"Pure Data": TypeProgramming, "Pure Data": Programming,
"PureBasic": TypeProgramming, "PureBasic": Programming,
"PureScript": TypeProgramming, "PureScript": Programming,
"Python": TypeProgramming, "Python": Programming,
"Python console": TypeProgramming, "Python console": Programming,
"Python traceback": TypeData, "Python traceback": Data,
"QML": TypeProgramming, "QML": Programming,
"QMake": TypeProgramming, "QMake": Programming,
"R": TypeProgramming, "R": Programming,
"RAML": TypeMarkup, "RAML": Markup,
"RDoc": TypeProse, "RDoc": Prose,
"REALbasic": TypeProgramming, "REALbasic": Programming,
"REXX": TypeProgramming, "REXX": Programming,
"RHTML": TypeMarkup, "RHTML": Markup,
"RMarkdown": TypeProse, "RMarkdown": Prose,
"RPM Spec": TypeData, "RPM Spec": Data,
"RUNOFF": TypeMarkup, "RUNOFF": Markup,
"Racket": TypeProgramming, "Racket": Programming,
"Ragel": TypeProgramming, "Ragel": Programming,
"Rascal": TypeProgramming, "Rascal": Programming,
"Raw token data": TypeData, "Raw token data": Data,
"Reason": TypeProgramming, "Reason": Programming,
"Rebol": TypeProgramming, "Rebol": Programming,
"Red": TypeProgramming, "Red": Programming,
"Redcode": TypeProgramming, "Redcode": Programming,
"Regular Expression": TypeData, "Regular Expression": Data,
"Ren'Py": TypeProgramming, "Ren'Py": Programming,
"RenderScript": TypeProgramming, "RenderScript": Programming,
"RobotFramework": TypeProgramming, "RobotFramework": Programming,
"Roff": TypeMarkup, "Roff": Markup,
"Rouge": TypeProgramming, "Rouge": Programming,
"Ruby": TypeProgramming, "Ruby": Programming,
"Rust": TypeProgramming, "Rust": Programming,
"SAS": TypeProgramming, "SAS": Programming,
"SCSS": TypeMarkup, "SCSS": Markup,
"SMT": TypeProgramming, "SMT": Programming,
"SPARQL": TypeData, "SPARQL": Data,
"SQF": TypeProgramming, "SQF": Programming,
"SQL": TypeData, "SQL": Data,
"SQLPL": TypeProgramming, "SQLPL": Programming,
"SRecode Template": TypeMarkup, "SRecode Template": Markup,
"STON": TypeData, "STON": Data,
"SVG": TypeData, "SVG": Data,
"Sage": TypeProgramming, "Sage": Programming,
"SaltStack": TypeProgramming, "SaltStack": Programming,
"Sass": TypeMarkup, "Sass": Markup,
"Scala": TypeProgramming, "Scala": Programming,
"Scaml": TypeMarkup, "Scaml": Markup,
"Scheme": TypeProgramming, "Scheme": Programming,
"Scilab": TypeProgramming, "Scilab": Programming,
"Self": TypeProgramming, "Self": Programming,
"Shell": TypeProgramming, "Shell": Programming,
"ShellSession": TypeProgramming, "ShellSession": Programming,
"Shen": TypeProgramming, "Shen": Programming,
"Slash": TypeProgramming, "Slash": Programming,
"Slim": TypeMarkup, "Slim": Markup,
"Smali": TypeProgramming, "Smali": Programming,
"Smalltalk": TypeProgramming, "Smalltalk": Programming,
"Smarty": TypeProgramming, "Smarty": Programming,
"SourcePawn": TypeProgramming, "SourcePawn": Programming,
"Spline Font Database": TypeData, "Spline Font Database": Data,
"Squirrel": TypeProgramming, "Squirrel": Programming,
"Stan": TypeProgramming, "Stan": Programming,
"Standard ML": TypeProgramming, "Standard ML": Programming,
"Stata": TypeProgramming, "Stata": Programming,
"Stylus": TypeMarkup, "Stylus": Markup,
"SubRip Text": TypeData, "SubRip Text": Data,
"Sublime Text Config": TypeData, "Sublime Text Config": Data,
"SuperCollider": TypeProgramming, "SuperCollider": Programming,
"Swift": TypeProgramming, "Swift": Programming,
"SystemVerilog": TypeProgramming, "SystemVerilog": Programming,
"TI Program": TypeProgramming, "TI Program": Programming,
"TLA": TypeProgramming, "TLA": Programming,
"TOML": TypeData, "TOML": Data,
"TXL": TypeProgramming, "TXL": Programming,
"Tcl": TypeProgramming, "Tcl": Programming,
"Tcsh": TypeProgramming, "Tcsh": Programming,
"TeX": TypeMarkup, "TeX": Markup,
"Tea": TypeMarkup, "Tea": Markup,
"Terra": TypeProgramming, "Terra": Programming,
"Text": TypeProse, "Text": Prose,
"Textile": TypeProse, "Textile": Prose,
"Thrift": TypeProgramming, "Thrift": Programming,
"Turing": TypeProgramming, "Turing": Programming,
"Turtle": TypeData, "Turtle": Data,
"Twig": TypeMarkup, "Twig": Markup,
"TypeScript": TypeProgramming, "TypeScript": Programming,
"Unified Parallel C": TypeProgramming, "Unified Parallel C": Programming,
"Unity3D Asset": TypeData, "Unity3D Asset": Data,
"Unix Assembly": TypeProgramming, "Unix Assembly": Programming,
"Uno": TypeProgramming, "Uno": Programming,
"UnrealScript": TypeProgramming, "UnrealScript": Programming,
"UrWeb": TypeProgramming, "UrWeb": Programming,
"VCL": TypeProgramming, "VCL": Programming,
"VHDL": TypeProgramming, "VHDL": Programming,
"Vala": TypeProgramming, "Vala": Programming,
"Verilog": TypeProgramming, "Verilog": Programming,
"Vim script": TypeProgramming, "Vim script": Programming,
"Visual Basic": TypeProgramming, "Visual Basic": Programming,
"Volt": TypeProgramming, "Volt": Programming,
"Vue": TypeMarkup, "Vue": Markup,
"Wavefront Material": TypeData, "Wavefront Material": Data,
"Wavefront Object": TypeData, "Wavefront Object": Data,
"Web Ontology Language": TypeMarkup, "Web Ontology Language": Markup,
"WebIDL": TypeProgramming, "WebIDL": Programming,
"World of Warcraft Addon Data": TypeData, "World of Warcraft Addon Data": Data,
"X10": TypeProgramming, "X10": Programming,
"XC": TypeProgramming, "XC": Programming,
"XCompose": TypeData, "XCompose": Data,
"XML": TypeData, "XML": Data,
"XPages": TypeProgramming, "XPages": Programming,
"XProc": TypeProgramming, "XProc": Programming,
"XQuery": TypeProgramming, "XQuery": Programming,
"XS": TypeProgramming, "XS": Programming,
"XSLT": TypeProgramming, "XSLT": Programming,
"Xojo": TypeProgramming, "Xojo": Programming,
"Xtend": TypeProgramming, "Xtend": Programming,
"YAML": TypeData, "YAML": Data,
"YANG": TypeData, "YANG": Data,
"Yacc": TypeProgramming, "Yacc": Programming,
"Zephir": TypeProgramming, "Zephir": Programming,
"Zimpl": TypeProgramming, "Zimpl": Programming,
"desktop": TypeData, "desktop": Data,
"eC": TypeProgramming, "eC": Programming,
"edn": TypeData, "edn": Data,
"fish": TypeProgramming, "fish": Programming,
"mupad": TypeProgramming, "mupad": Programming,
"nesC": TypeProgramming, "nesC": Programming,
"ooc": TypeProgramming, "ooc": Programming,
"reStructuredText": TypeProse, "reStructuredText": Prose,
"wisp": TypeProgramming, "wisp": Programming,
"xBase": TypeProgramming, "xBase": Programming,
} }

18
type_test.go
View File

@ -4,29 +4,29 @@ import . "gopkg.in/check.v1"
func (s *TSuite) TestGetLanguageType(c *C) { func (s *TSuite) TestGetLanguageType(c *C) {
langType := GetLanguageType("BestLanguageEver") langType := GetLanguageType("BestLanguageEver")
c.Assert(langType, Equals, TypeUnknown) c.Assert(langType, Equals, Unknown)
langType = GetLanguageType("JSON") langType = GetLanguageType("JSON")
c.Assert(langType, Equals, TypeData) c.Assert(langType, Equals, Data)
langType = GetLanguageType("COLLADA") langType = GetLanguageType("COLLADA")
c.Assert(langType, Equals, TypeData) c.Assert(langType, Equals, Data)
langType = GetLanguageType("Go") langType = GetLanguageType("Go")
c.Assert(langType, Equals, TypeProgramming) c.Assert(langType, Equals, Programming)
langType = GetLanguageType("Brainfuck") langType = GetLanguageType("Brainfuck")
c.Assert(langType, Equals, TypeProgramming) c.Assert(langType, Equals, Programming)
langType = GetLanguageType("HTML") langType = GetLanguageType("HTML")
c.Assert(langType, Equals, TypeMarkup) c.Assert(langType, Equals, Markup)
langType = GetLanguageType("Sass") langType = GetLanguageType("Sass")
c.Assert(langType, Equals, TypeMarkup) c.Assert(langType, Equals, Markup)
langType = GetLanguageType("AsciiDoc") langType = GetLanguageType("AsciiDoc")
c.Assert(langType, Equals, TypeProse) c.Assert(langType, Equals, Prose)
langType = GetLanguageType("Textile") langType = GetLanguageType("Textile")
c.Assert(langType, Equals, TypeProse) c.Assert(langType, Equals, Prose)
} }

2
vendor_matchers.go
View File

@ -1,6 +1,6 @@
package slinguist package slinguist
// CODE GENERATED AUTOMATICALLY WITH github.com/src-d/simple-linguist/cli/slinguist-generate // CODE GENERATED AUTOMATICALLY WITH gopkg.in/src-d/simple-linguist.v1/internal/code-generator
// THIS FILE SHOULD NOT BE EDITED BY HAND // THIS FILE SHOULD NOT BE EDITED BY HAND
// Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9 // Extracted from github/linguist commit: dae33dc2b20cddc85d1300435c3be7118a7115a9