WIP - Detect Forth over F#

pkg/language/language.go

@@ -3,12 +3,10 @@
 import (
 	"context"
 	"fmt"
-	"io"
 	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/wakatime/wakatime-cli/pkg/file"
 	"github.com/wakatime/wakatime-cli/pkg/heartbeat"
 	"github.com/wakatime/wakatime-cli/pkg/log"
 )
@@ -63,6 +61,8 @@
 // Detect detects the language of a specific file. If guessLanguage is true,
 // Chroma will be used to detect a language from the file contents.
 func Detect(ctx context.Context, fp string, guessLanguage bool) (heartbeat.Language, error) {
+	logger := log.Extract(ctx)
+
 	if language, ok := detectSpecialCases(ctx, fp); ok {
 		return language, nil
 	}
@@ -74,7 +74,16 @@
 		language = languageChroma
 	}
 
-	language = detectOverrideCases(ctx, fp, language, weight)
+	head, err := fileHead(ctx, fp)
+	if err != nil {
+		logger.Warnf("failed to load head from file %q: %s", fp, err)
+	}
+
+	languageVim, weightVim, okVim := detectVimModeline(string(head))
+	if okVim && weightVim > weight {
+		// use language from vim modeline, if weight is higher
+		language = languageVim
+	}
 
 	if language == heartbeat.LanguageUnknown {
 		return heartbeat.LanguageUnknown, fmt.Errorf("could not detect the language of file %q", fp)
@@ -129,54 +138,6 @@
 	return heartbeat.LanguageUnknown, false
 }
 
-// detectOverrideCases overwrides the Chroma detected language based on file contents.
-func detectOverrideCases(ctx context.Context, fp string, language heartbeat.Language, weight float32) heartbeat.Language {
-	logger := log.Extract(ctx)
-
-	f, err := file.OpenNoLock(fp) // nolint:gosec
-	if err != nil {
-		logger.Debugf("failed to open file: %s", err)
-		return language
-	}
-
-	defer func() {
-		if err := f.Close(); err != nil {
-			logger.Debugf("failed to close file: %s", err)
-		}
-	}()
-
-	buf := make([]byte, 4096)
-	c, err := f.Read(buf)
-	if err != nil && err != io.EOF {
-		logger.Debugf("failed to open file: %s", err)
-		return language
-	}
-
-	text := string(buf[:c])
-
-	languageVim, weightVim, okVim := detectVimModeline(text)
-	if okVim && weightVim > weight {
-		language = languageVim
-	}
-
-	_, file := filepath.Split(fp)
-	ext := strings.ToLower(filepath.Ext(file))
-
-	if ext == ".fs" {
-		languageForth, weightForth, okForth := detectForthFromContents(text)
-		if okForth && weightForth >= weight {
-			language = languageForth
-		}
-
-		languageFSharp, weightFSharp, okFSharp := detectFSharpFromContents(text)
-		if okFSharp && weightFSharp >= weight {
-			language = languageFSharp
-		}
-	}
-
-	return language
-}
-
 // folderContainsCFiles returns true, if filder contains c files.
 func folderContainsCFiles(ctx context.Context, dir string) bool {
 	if dir == "" {

pkg/language/language_test.go

@@ -250,11 +250,11 @@ func TestDetect_Perl_Over_Prolog(t *testing.T) {
 	assert.Equal(t, heartbeat.LanguagePerl, lang)
 }
 
-func TestDetect_FSharp_Over_Forth(t *testing.T) {
+func TestDetect_Forth_Over_FSharp(t *testing.T) {
 	lang, err := language.Detect(t.Context(), "testdata/codefiles/fsharp.fs", false)
 	require.NoError(t, err)
 
-	assert.Equal(t, heartbeat.LanguageFSharp, lang)
+	assert.Equal(t, heartbeat.LanguageForth, lang)
 }
 
 func TestDetect_ChromaTopLanguagesRetrofit(t *testing.T) {

pkg/language/priority.go

@@ -3,16 +3,18 @@ package language
 func priority(lang string) (float32, bool) {
 	prios := map[string]float32{
 		"FSharp": 0.01,
-		// Higher priority than the ca 65 assembler and ArmAsm
+		// Higher priority than FSharp
+		"Forth": 0.05,
+		// Higher priority than ca 65 assembler and ArmAsm
 		"GAS": 0.1,
-		// Higher priority than the ca Inform 6
+		// Higher priority than ca Inform 6
 		"INI": 0.1,
 		// TASM uses the same file endings, but TASM is not as common as NASM, so we prioritize NASM higher by default.
 		"NASM": 0.1,
 		"Perl": 0.01,
 		// Higher priority than Rebol
 		"R": 0.1,
-		// Higher priority than the TypoScript, as TypeScript is far more
+		// Higher priority than TypoScript, as TypeScript is far more
 		// common these days
 		"TypeScript": 0.5,
 	}