keywords.go

package calculate

import "strings"

func countKeywords(line string, language Language) float64 {
	keywords, found := languageToKeywords[language]
	if !found {
		return 0
	}
	keywordsCount := float64(0)
	tokens := strings.Fields(line)
	tokensSet := make(map[string]bool, len(tokens))
	for _, token := range strings.Fields(line) {
		if strings.HasPrefix(token, "@") && !strings.HasPrefix(token, "@\"") {
			if _, found := languagesWithAtSignPrefix[language]; found {
				keywordsCount++
			}
		}
		token = strings.TrimRight(strings.TrimRight(token, ";"), "{")
		tokensSet[token] = true
	}
	for _, keyword := range keywords {
		if _, found := tokensSet[keyword]; found {
			keywordsCount++
		}
	}
	return keywordsCount
}

var languageToKeywords = map[Language][]string{
	"java": {
		"break",
		"case",
		"catch",
		"class",
		"continue",
		"do",
		"else",
		"enum",
		"extends",
		"finally",
		"for",
		"goto",
		"if",
		"implement",
		"imports",
		"interface",
		"return",
		"switch",
		"throw",
		"try",
		"while",
	},
	"csharp": {
		"await",
		"break",
		"case",
		"catch",
		"class",
		"continue",
		"delegate",
		"do",
		"else",
		"enum",
		"event",
		"extern",
		"finally",
		"for",
		"foreach",
		"goto",
		"if",
		"init",
		"interface",
		"return",
		"struct",
		"switch",
		"throw",
		"try",
		"while",
		"from",
		"get",
		"set",
		"join",
		"let",
		"using",
		"yield",
	},
	"node": {
		"await",
		"break",
		"case",
		"catch",
		"class",
		"continue",
		"do",
		"else",
		"enum",
		"eval",
		"extends",
		"finally",
		"for",
		"function",
		"goto",
		"if",
		"implements",
		"import",
		"in",
		"interface",
		"package",
		"return",
		"switch",
		"try",
		"while",
		"with",
		"yield",
	},
	"python": {
		"break",
		"class",
		"continue",
		"def",
		"elif",
		"else",
		"except",
		"finally",
		"for",
		"from",
		"if",
		"import",
		"in",
		"lambda",
		"pass",
		"raise",
		"return",
		"try",
		"yield",
		"with",
		"while",
	},
	"kotlin": {
		"break",
		"class",
		"continue",
		"do",
		"else",
		"for",
		"fun",
		"if",
		"interface",
		"return",
		"throw",
		"try",
		"typealias",
		"when",
		"while",
		"catch",
		"constructor",
		"delegate",
		"field",
		"finally",
		"get",
		"import",
		"init",
		"property",
		"receiver",
		"set",
		"setparam",
		"where",
		"enum",
	},
	"c": {
		"break",
		"case",
		"continue",
		"do",
		"else",
		"for",
		"goto",
		"if",
		"return",
		"struct",
		"switch",
		"typedef",
		"union",
		"while",
		"enum",
		"#define",
		"#ifdef",
		"#ifndef",
		"#include",
	},
	"cpp": {
		"break",
		"case",
		"catch",
		"class",
		"continue",
		"do",
		"else",
		"for",
		"goto",
		"if",
		"namespace",
		"return",
		"struct",
		"switch",
		"template",
		"throw",
		"try",
		"typename",
		"typedef",
		"union",
		"using",
		"while",
		"#define",
		"#ifdef",
		"#ifndef",
		"#include",
	},
	"objectivec": {
		"break",
		"case",
		"continue",
		"do",
		"else",
		"enum",
		"for",
		"goto",
		"if",
		"return",
		"struct",
		"switch",
		"typedef",
		"union",
		"while",
		"#import",
	},
	"swift": {
		"class",
		"deinit",
		"enum",
		"extension",
		"func",
		"import",
		"init",
		"protocol",
		"struct",
		"subscript",
		"typealias",
		"break",
		"case",
		"continue",
		"do",
		"else",
		"fallthrough",
		"for",
		"if",
		"in",
		"return",
		"switch",
		"where",
		"while",
		"didSet",
		"get",
		"set",
		"willSet",
	},
	"ruby": {
		"begin",
		"break",
		"case",
		"class",
		"def",
		"do",
		"else",
		"elsif",
		"end",
		"ensure",
		"for",
		"if",
		"in",
		"include",
		"load",
		"module",
		"next",
		"redo",
		"rescue",
		"retry",
		"return",
		"require",
		"require_relative",
		"then",
		"unless",
		"until",
		"when",
		"while",
		"yield",
	},
	"go": {
		"break",
		"case",
		"continue",
		"defer",
		"else",
		"fallthrough",
		"for",
		"func",
		"go",
		"goto",
		"if",
		"import",
		"interface",
		"range",
		"return",
		"select",
		"struct",
		"switch",
	},
	"rust": {
		"break",
		"continue",
		"else",
		"enum",
		"extern",
		"fn",
		"for",
		"if",
		"impl",
		"loop",
		"match",
		"return",
		"struct",
		"trait",
		"use",
		"where",
		"while",
		"async",
		"await",
		"do",
		"macro",
		"yield",
		"try",
		"union",
		"macro_rules",
	},
	"scala": {
		"case",
		"catch",
		"class",
		"def",
		"do",
		"else",
		"extends",
		"finally",
		"for",
		"forSome",
		"if",
		"import",
		"match",
		"return",
		"throw",
		"trait",
		"try",
		"type",
		"while",
		"with",
		"yield",
	},
	"php": {
		"abstract",
		"and",
		"as",
		"break",
		"callable",
		"case",
		"catch",
		"class",
		"clone",
		"const",
		"continue",
		"declare",
		"default",
		"do",
		"echo",
		"else",
		"elseif",
		"enddeclare",
		"endfor",
		"endforeach",
		"endif",
		"endswitch",
		"endwhile",
		"extends",
		"final",
		"finally",
		"for",
		"foreach",
		"function",
		"global",
		"goto",
		"if",
		"implements",
		"include",
		"include_once",
		"instanceof",
		"insteadof",
		"interface",
		"match",
		"namespace",
		"new",
		"or",
		"print",
		"private",
		"protected",
		"public",
		"require",
		"require_once",
		"return",
		"static",
		"switch",
		"throw",
		"trait",
		"try",
		"use",
		"var",
		"while",
		"xor",
		"yield",
	},
	"fortran": {
		"abstract",
		"allocatable",
		"allocate",
		"assign",
		"associate",
		"asynchronous",
		"backspace",
		"block",
		"block data",
		"case",
		"codimension",
		"common",
		"contains",
		"contiguous",
		"critical",
		"cycle",
		"data",
		"deallocate",
		"deferred",
		"do",
		"do concurrent",
		"else",
		"else if",
		"end",
		"endfile",
		"endif",
		"entry",
		"equivalence",
		"external",
		"final",
		"flush",
		"format",
		"forall",
		"function",
		"generic",
		"goto",
		"if",
		"implicit",
		"include",
		"inquire",
		"intrinsic",
		"lock",
		"module",
		"namelist",
		"nullify",
		"only",
		"operator",
		"optional",
		"pause",
		"pass",
		"pointer",
		"procedure",
		"program",
		"private",
		"public",
		"recursive",
		"result",
		"rewrite",
		"save",
		"select",
		"select rank",
		"sequence",
		"stop",
		"submodule",
		"subroutine",
		"sync all",
		"sync images",
		"sync memory",
		"target",
		"then",
		"use",
		"volatile",
		"wait",
		"while",
		"write",
		"impure",
		"error stop",
		"non_overridable",
		"non_recursive",
		"import (in interfaces)",
		"element",
		"elemental",
		"extend",
		"enumerator",
	},
}

var languagesWithAtSignPrefix = map[Language]bool{
	"java":       true,
	"objectivec": true,
	"python":     true,
	"kotlin":     true,
	"scala":      true,
	"node":       true,
}