added type.go generation

internal/code-generator/assets/type.go.tmpl

@@ -0,0 +1,24 @@
+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: {{ getCommit }}
+
+const (
+	TypeUnknown     = iota
+	TypeData        = iota
+	TypeProgramming = iota
+	TypeMarkup      = iota
+	TypeProse       = iota
+)
+
+func GetLanguageType(language string) (langType int) {
+	langType, _ = languagesType[language]
+	return langType
+}
+
+var languagesType = map[string]int{
+	{{range $language, $type := . -}}
+	"{{ $language }}": {{ $type -}},
+	{{end -}}
+}

internal/code-generator/generator/generator_test.go

@@ -17,6 +17,7 @@ const (
 	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
 	ymlTestFile           = "test_files/languages.test.yml"
@@ -41,6 +42,12 @@ const (
 	documentationGold         = "test_files/documentation.gold"
 	documentationTestTmplPath = "test_files/documentation.test.go.tmpl"
 	documentationTestTmplName = "documentation.test.go.tmpl"
+
+	// Types test
+	typesTestFile     = "test_files/type.test.yml"
+	typesGold         = "test_files/type.gold"
+	typesTestTmplPath = "test_files/type.test.go.tmpl"
+	typesTestTmplName = "type.test.go.tmpl"
 )
 
 func TestFromFile(t *testing.T) {
@@ -56,6 +63,9 @@ func TestFromFile(t *testing.T) {
 	goldDocumentation, err := ioutil.ReadFile(formatedDocumentationGold)
 	assert.NoError(t, err)
 
+	goldTypes, err := ioutil.ReadFile(formatedTypesGold)
+	assert.NoError(t, err)
+
 	outPathLang, err := ioutil.TempFile("/tmp", "generator-test-")
 	assert.NoError(t, err)
 	defer os.Remove(outPathLang.Name())
@@ -72,6 +82,10 @@ func TestFromFile(t *testing.T) {
 	assert.NoError(t, err)
 	defer os.Remove(outPathDocumentation.Name())
 
+	outPathTypes, err := ioutil.TempFile("/tmp", "generator-test-")
+	assert.NoError(t, err)
+	defer os.Remove(outPathTypes.Name())
+
 	tests := []struct {
 		name        string
 		fileToParse string
@@ -122,6 +136,16 @@ func TestFromFile(t *testing.T) {
 			generate:    Documentation,
 			wantOut:     goldDocumentation,
 		},
+		{
+			name:        "tyTestFromFile_Types",
+			fileToParse: typesTestFile,
+			outPath:     outPathTypes.Name(),
+			tmplPath:    typesTestTmplPath,
+			tmplName:    typesTestTmplName,
+			commit:      commitTest,
+			generate:    Types,
+			wantOut:     goldTypes,
+		},
 	}
 
 	for _, tt := range tests {
@@ -270,3 +294,37 @@ func TestDocumentation(t *testing.T) {
 		})
 	}
 }
+
+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)))
+		})
+	}
+}

internal/code-generator/generator/langs.go

@@ -10,11 +10,11 @@ import (
 )
 
 type languageInfo struct {
-	Type         string   `yaml:"type,omitempty" json:"type,omitempty"`
-	Aliases      []string `yaml:"aliases,omitempty,flow" json:"aliases,omitempty"`
-	Extensions   []string `yaml:"extensions,omitempty,flow" json:"extensions,omitempty"`
-	Interpreters []string `yaml:"interpreters,omitempty,flow" json:"interpreters,omitempty"`
-	Group        string   `yaml:"group,omitempty" json:"group,omitempty"`
+	Type         string   `yaml:"type,omitempty"`
+	Aliases      []string `yaml:"aliases,omitempty,flow"`
+	Extensions   []string `yaml:"extensions,omitempty,flow"`
+	Interpreters []string `yaml:"interpreters,omitempty,flow"`
+	Group        string   `yaml:"group,omitempty"`
 }
 
 // Languages reads from buf and builds languages.go file from languagesTmplPath.
@@ -24,10 +24,7 @@ func Languages(data []byte, languagesTmplPath, languagesTmplName, commit string)
 		return nil, err
 	}
 
-	languagesByExtension, err := buildExtensionLanguageMap(languages)
-	if err != nil {
-		return nil, err
-	}
+	languagesByExtension := buildExtensionLanguageMap(languages)
 
 	buf := &bytes.Buffer{}
 	if err := executeLanguagesTemplate(buf, languagesByExtension, languagesTmplPath, languagesTmplName, commit); err != nil {
@@ -37,7 +34,7 @@ func Languages(data []byte, languagesTmplPath, languagesTmplName, commit string)
 	return buf.Bytes(), nil
 }
 
-func buildExtensionLanguageMap(languages map[string]*languageInfo) (map[string][]string, error) {
+func buildExtensionLanguageMap(languages map[string]*languageInfo) map[string][]string {
 	extensionLangsMap := make(map[string][]string)
 	for lang, info := range languages {
 		for _, extension := range info.Extensions {
@@ -45,7 +42,7 @@ func buildExtensionLanguageMap(languages map[string]*languageInfo) (map[string][
 		}
 	}
 
-	return extensionLangsMap, nil
+	return extensionLangsMap
 }
 
 func executeLanguagesTemplate(out io.Writer, languagesByExtension map[string][]string, languagesTmplPath, languagesTmpl, commit string) error {

internal/code-generator/generator/test_files/formated_type.gold

@@ -0,0 +1,25 @@
+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
+
+const (
+	TypeUnknown     = iota
+	TypeData        = iota
+	TypeProgramming = iota
+	TypeMarkup      = iota
+	TypeProse       = iota
+)
+
+func GetLanguageType(language string) (langType int) {
+	langType, _ = languagesType[language]
+	return langType
+}
+
+var languagesType = map[string]int{
+	"Scaml":  TypeMarkup,
+	"Scheme": TypeProgramming,
+	"Scilab": TypeProgramming,
+	"Self":   TypeProgramming,
+}

internal/code-generator/generator/test_files/type.gold

@@ -0,0 +1,25 @@
+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
+
+const (
+	TypeUnknown     = iota
+	TypeData        = iota
+	TypeProgramming = iota
+	TypeMarkup      = iota
+	TypeProse       = iota
+)
+
+func GetLanguageType(language string) (langType int) {
+	langType, _ = languagesType[language]
+	return langType
+}
+
+var languagesType = map[string]int{
+	"Scaml": TypeMarkup,
+	"Scheme": TypeProgramming,
+	"Scilab": TypeProgramming,
+	"Self": TypeProgramming,
+	}

internal/code-generator/generator/test_files/type.test.go.tmpl

@@ -0,0 +1,24 @@
+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: {{ getCommit }}
+
+const (
+	TypeUnknown     = iota
+	TypeData        = iota
+	TypeProgramming = iota
+	TypeMarkup      = iota
+	TypeProse       = iota
+)
+
+func GetLanguageType(language string) (langType int) {
+	langType, _ = languagesType[language]
+	return langType
+}
+
+var languagesType = map[string]int{
+	{{range $language, $type := . -}}
+	"{{ $language }}": {{ $type -}},
+	{{end -}}
+}

internal/code-generator/generator/test_files/type.test.yml

@@ -0,0 +1,46 @@
+---
+Scaml:
+  group: HTML
+  type: markup
+  extensions:
+  - ".scaml"
+  tm_scope: source.scaml
+  ace_mode: text
+  language_id: 342
+Scheme:
+  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:
+  type: programming
+  extensions:
+  - ".sci"
+  - ".sce"
+  - ".tst"
+  ace_mode: text
+  language_id: 344
+Self:
+  type: programming
+  color: "#0579aa"
+  extensions:
+  - ".self"
+  tm_scope: none
+  ace_mode: text
+  language_id: 345
+  

internal/code-generator/generator/types.go

@@ -0,0 +1,55 @@
+package generator
+
+import (
+	"bytes"
+	"io"
+	"text/template"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+var typeToTypeConst = map[string]string{
+	"data":        "TypeData",
+	"programming": "TypeProgramming",
+	"markup":      "TypeMarkup",
+	"prose":       "TypeProse",
+}
+
+// Types reads from buf and builds type.go file from typeTmplPath.
+func Types(data []byte, typeTmplPath, typeTmplName, commit string) ([]byte, error) {
+	languages := make(map[string]*languageInfo)
+	if err := yaml.Unmarshal(data, &languages); err != nil {
+		return nil, err
+	}
+
+	langTypeMap := buildLanguageTypeMap(languages)
+
+	buf := &bytes.Buffer{}
+	if err := executeTypesTemplate(buf, langTypeMap, typeTmplPath, typeTmplName, commit); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func buildLanguageTypeMap(languages map[string]*languageInfo) map[string]string {
+	langTypeMap := make(map[string]string)
+	for lang, info := range languages {
+		langTypeMap[lang] = typeToTypeConst[info.Type]
+	}
+
+	return langTypeMap
+}
+
+func executeTypesTemplate(out io.Writer, langTypeMap map[string]string, typeTmplPath, typeTmpl, commit string) error {
+	fmap := template.FuncMap{
+		"getCommit": func() string { return commit },
+	}
+
+	t := template.Must(template.New(typeTmpl).Funcs(fmap).ParseFiles(typeTmplPath))
+	if err := t.Execute(out, langTypeMap); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/code-generator/main.go

@@ -28,29 +28,40 @@ const (
 	documentationTmplPath = "internal/code-generator/assets/documentation.go.tmpl"
 	documentationTmpl     = "documentation.go.tmpl"
 
+	typeFile     = "type.go"
+	typeTmplPath = "internal/code-generator/assets/type.go.tmpl"
+	typeTmpl     = "type.go.tmpl"
+
 	commitPath = ".git/refs/heads/master"
 )
 
+type generatorArgs struct {
+	fileToParse string
+	outPath     string
+	tmplPath    string
+	tmplName    string
+	commit      string
+	generate    generator.Func
+}
+
 func main() {
 	commit, err := getCommit(commitPath)
 	if err != nil {
 		log.Printf("couldn't find commit: %v", err)
 	}
 
-	if err := generator.FromFile(languagesYAML, langFile, languagesTmplPath, languagesTmpl, commit, generator.Languages); err != nil {
-		log.Println(err)
+	argsList := []*generatorArgs{
+		&generatorArgs{languagesYAML, langFile, languagesTmplPath, languagesTmpl, commit, generator.Languages},
+		&generatorArgs{heuristicsRuby, contentFile, contentTmplPath, contentTmpl, commit, generator.Heuristics},
+		&generatorArgs{vendorYAML, vendorFile, vendorTmplPath, vendorTmpl, commit, generator.Vendor},
+		&generatorArgs{documentationYAML, documentationFile, documentationTmplPath, documentationTmpl, commit, generator.Documentation},
+		&generatorArgs{languagesYAML, typeFile, typeTmplPath, typeTmpl, commit, generator.Types},
 	}
 
-	if err := generator.FromFile(heuristicsRuby, contentFile, contentTmplPath, contentTmpl, commit, generator.Heuristics); err != nil {
-		log.Println(err)
-	}
-
-	if err := generator.FromFile(vendorYAML, vendorFile, vendorTmplPath, vendorTmpl, commit, generator.Vendor); err != nil {
-		log.Println(err)
-	}
-
-	if err := generator.FromFile(documentationYAML, documentationFile, documentationTmplPath, documentationTmpl, commit, generator.Documentation); err != nil {
-		log.Println(err)
+	for _, args := range argsList {
+		if err := generator.FromFile(args.fileToParse, args.outPath, args.tmplPath, args.tmplName, args.commit, args.generate); err != nil {
+			log.Println(err)
+		}
 	}
 }