From 6ec5f8a71a07ab89f751ef1186efb3d4143e676e Mon Sep 17 00:00:00 2001 From: andrey pechorin Date: Sat, 29 Oct 2022 00:51:48 +0300 Subject: [PATCH] any-jump 0.6 (#100) --- README.md | 97 ++++--- autoload/lang_map.vim | 263 +++++++++++++++--- autoload/search.vim | 2 +- generator/.ruby-version | 1 + generator/Gemfile | 2 + generator/Gemfile.lock | 42 ++- generator/README.md | 24 ++ generator/Rakefile | 40 +++ generator/lang_map.rb | 142 ---------- .../{lang_map.el => lang_map_downloaded.el} | 174 +++++++++--- generator/lang_map_generated.vim | 257 ++++++++++++++--- generator/lib/download.rb | 37 +++ generator/lib/generate.rb | 176 ++++++++++++ plugin/any-jump.vim | 23 +- 14 files changed, 955 insertions(+), 325 deletions(-) create mode 100644 generator/.ruby-version create mode 100644 generator/README.md create mode 100644 generator/Rakefile delete mode 100644 generator/lang_map.rb rename generator/{lang_map.el => lang_map_downloaded.el} (88%) create mode 100644 generator/lib/download.rb create mode 100644 generator/lib/generate.rb diff --git a/README.md b/README.md index 3cb0a87..c59ae0e 100644 --- a/README.md +++ b/README.md @@ -44,14 +44,6 @@ With `:AnyJumpArg myKeyword` command you can manually write what you want to be - **keyword references/usages**: find files where keyword used and referenced -## version 1.0 roadmap - -- [ ] paths priorities for better search results -- [ ] [nvim] ability to jump through preview text (and another keyword) -- [ ] show latest N search keywords in popup to save jumping history -- [ ] ctags support -- [ ] basic refactoring support - ## Keybindings Default global mappings for normal and visual modes: @@ -221,60 +213,77 @@ Where are also `PmenuSel`, `PmenuSbar`, `PmenuThumb` groups for configuring. ## Supported languages -- ruby -- elixir +- apex +- c++ +- clojure +- coffeescript +- commonlisp +- coq - crystal -- rust +- csharp +- dart +- elisp +- elixir +- erlang +- faust +- fennel +- fortran +- fsharp +- go +- groovy - haskell +- hcl - java - javascript -- typescript -- scala +- julia - kotlin -- php -- protobuf -- scss -- fsharp -- c++ -- coffeescript -- go - lua +- matlab - nim -- scad -- elisp - nix -- clojure -- coq -- systemverilog - objc +- ocaml +- pascal +- perl +- php +- protobuf +- python +- r - racket -- vhdl +- ruby +- rust +- scad +- scala - scheme -- r -- sql -- faust -- vala -- matlab -- python -- pascal -- tex -- swift +- scss - shell -- perl -- csharp -- commonlisp -- ocaml -- erlang -- julia - sml -- groovy -- dart -- fortran +- solidity +- sql +- swift +- systemverilog +- tcl +- tex +- typescript +- vala +- vhdl +- zig ## Original idea Comes from dumb-jump.el emacs package +## Development + +### Lang generator + +You need ruby to run generator script which actually download language map, parse, extract data and then generate vim representation: + +```bash +cd generator +bundle exec rake update +``` + ## Issues and contributions Please open issue on any question / problem / feedback / idea. diff --git a/autoload/lang_map.vim b/autoload/lang_map.vim index cd89527..fbb6406 100644 --- a/autoload/lang_map.vim +++ b/autoload/lang_map.vim @@ -5,9 +5,9 @@ let s:definitions = {} " map any-language to concrete internal s:definitions[language] let s:filetypes_proxy = { - \"javascriptreact": "javascript", - \"c": "cpp", - \} + \"javascriptreact": "javascript", + \"c": "cpp", + \} fu! s:add_definition(lang, definition) abort if !has_key(s:definitions, a:lang) @@ -56,6 +56,15 @@ call s:add_definition('elisp', { \"spec_failed": ["(defun test-asdf (blah)","(defun test-blah\n","(cl-defun test-asdf (blah)","(cl-defun test-blah\n","(defun tester (blah)","(defun test? (blah)","(defun test- (blah)"], \}) +call s:add_definition('elisp', { + \"type": 'function', + \"pcre2_regexp": '\(defmacro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(defmacro\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(defmacro test (blah)","(defmacro test\n"], + \"spec_failed": ["(defmacro test-asdf (blah)","(defmacro test-blah\n","(defmacro tester (blah)","(defmacro test? (blah)","(defmacro test- (blah)"], + \}) + call s:add_definition('elisp', { \"type": 'variable', \"pcre2_regexp": '\(defvar\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])', @@ -160,7 +169,7 @@ call s:add_definition('racket', { \"pcre2_regexp": '(\(|\[)\s*KEYWORD\s+', \"emacs_regexp": '(\(|\[)\s*JJJ\s+', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["(let ((test ''foo","(let [(test ''foo","(let [(test ''foo","(let [[test ''foo","(let ((blah ''foo) (test ''bar)"], + \"spec_success": ["(let ((test 'foo","(let [(test 'foo","(let [(test 'foo","(let [[test 'foo","(let ((blah 'foo) (test 'bar)"], \"spec_failed": ["{test foo"], \}) @@ -256,10 +265,10 @@ call s:add_definition('scheme', { call s:add_definition('cpp', { \"type": 'function', - \"pcre2_regexp": '\bKEYWORD(\s|\))*\((\w|[,&*.<>]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+KEYWORD(\)|\s)*\(', - \"emacs_regexp": '\bJJJ(\s|\))*\((\w|[,&*.<>]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+JJJ(\)|\s)*\(', + \"pcre2_regexp": '\bKEYWORD(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+KEYWORD(\)|\s)*\(', + \"emacs_regexp": '\bJJJ(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+JJJ(\)|\s)*\(', \"supports": ["ag", "rg", "git-grep"], - \"spec_success": ["int test(){","my_struct (*test)(int a, int b){","auto MyClass::test ( Builder& reference, ) -> decltype( builder.func() ) {","int test( int *random_argument) const {","test::test() {","typedef int (*test)(int);"], + \"spec_success": ["int test(){","my_struct (*test)(int a, int b){","auto MyClass::test ( Builder::Builder& reference, ) -> decltype( builder.func() ) {","int test( int *random_argument) const {","test::test() {","typedef int (*test)(int);"], \"spec_failed": ["return test();)","int test(a, b);","if( test() ) {","else test();"], \}) @@ -454,20 +463,29 @@ call s:add_definition('swift', { call s:add_definition('swift', { \"type": 'function', - \"pcre2_regexp": 'func\s*KEYWORD\b\s*\(', - \"emacs_regexp": 'func\s*JJJ\b\s*\(', + \"pcre2_regexp": 'func\s+KEYWORD\b\s*(<[^>]*>)?\s*\(', + \"emacs_regexp": 'func\s+JJJ\b\s*(<[^>]*>)?\s*\(', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["func test(asdf)","func test()"], + \"spec_success": ["func test(asdf)","func test()","func test()"], \"spec_failed": ["func testnot(asdf)","func testnot()"], \}) call s:add_definition('swift', { \"type": 'type', - \"pcre2_regexp": '(class|struct)\s*KEYWORD\b\s*?', - \"emacs_regexp": '(class|struct)\s*JJJ\b\s*?', + \"pcre2_regexp": '(class|struct|protocol|enum)\s+KEYWORD\b\s*?', + \"emacs_regexp": '(class|struct|protocol|enum)\s+JJJ\b\s*?', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["class test:","class test: UIWindow"], - \"spec_failed": ["class testnot:","class testnot(object):"], + \"spec_success": ["struct test","struct test: Codable","struct test","class test:","class test: UIWindow","class test"], + \"spec_failed": ["class testnot:","class testnot(object):","struct testnot(object)"], + \}) + +call s:add_definition('swift', { + \"type": 'type', + \"pcre2_regexp": '(typealias)\s+KEYWORD\b\s*?=', + \"emacs_regexp": '(typealias)\s+JJJ\b\s*?=', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["typealias test ="], + \"spec_failed": ["typealias testnot"], \}) call s:add_definition('csharp', { @@ -688,28 +706,28 @@ call s:add_definition('matlab', { call s:add_definition('nim', { \"type": 'variable', - \"pcre2_regexp": '(const|let|var)\s*KEYWORD\s*(=|:)[^=:\n]+', - \"emacs_regexp": '(const|let|var)\s*JJJ\s*(=|:)[^=:\n]+', + \"pcre2_regexp": '(const|let|var)\s*KEYWORD\*?\s*(=|:)[^=:\n]+', + \"emacs_regexp": '(const|let|var)\s*JJJ\*?\s*(=|:)[^=:\n]+', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["let test = 1234","var test = 1234","var test: Stat","const test = 1234"], + \"spec_success": ["let test = 1234","var test = 1234","var test: Stat","const test = 1234","const test* = 1234"], \"spec_failed": ["if test == 1234:"], \}) call s:add_definition('nim', { \"type": 'function', - \"pcre2_regexp": '(proc|func|macro|template)\s*\`?KEYWORD\`?\b\s*\(', - \"emacs_regexp": '(proc|func|macro|template)\s*`?JJJ`?\b\s*\(', + \"pcre2_regexp": '(proc|func|macro|template)\s*`?KEYWORD`?\b\*?\s*\(', + \"emacs_regexp": '(proc|func|macro|template)\s*`?JJJ`?\b\*?\s*\(', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["\tproc test(asdf)","proc test()","func test()","macro test()","template test()"], + \"spec_success": ["\tproc test(asdf)","proc test()","func test()","macro test()","template test()","proc test*()"], \"spec_failed": ["\tproc testnot(asdf)","proc testnot()"], \}) call s:add_definition('nim', { \"type": 'type', - \"pcre2_regexp": 'type\s*KEYWORD\b\s*(\{[^}]+\})?\s*=\s*\w+', - \"emacs_regexp": 'type\s*JJJ\b\s*(\{[^}]+\})?\s*=\s*\w+', + \"pcre2_regexp": 'type\s*KEYWORD\b\*?\s*(\{[^}]+\})?\s*=\s*\w+', + \"emacs_regexp": 'type\s*JJJ\b\*?\s*(\{[^}]+\})?\s*=\s*\w+', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["type test = object","type test {.pure.} = enum"], + \"spec_success": ["type test = object","type test {.pure.} = enum","type test* = ref object"], \"spec_failed": ["type testnot = object"], \}) @@ -947,6 +965,42 @@ call s:add_definition('scala', { \"spec_failed": [], \}) +call s:add_definition('solidity', { + \"type": 'function', + \"pcre2_regexp": 'function\s*KEYWORD\s*\(', + \"emacs_regexp": 'function\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["function test() internal","function test (uint x, address y)","function test() external"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'modifier', + \"pcre2_regexp": 'modifier\s*KEYWORD\s*\(', + \"emacs_regexp": 'modifier\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["modifier test()","modifier test ()"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'event', + \"pcre2_regexp": 'event\s*KEYWORD\s*\(', + \"emacs_regexp": 'event\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["event test();","event test (uint indexed x)","event test(uint x, address y)"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'error', + \"pcre2_regexp": 'error\s*KEYWORD\s*\(', + \"emacs_regexp": 'error\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["error test();","error test (uint x)","error test(uint x, address y)"], + \"spec_failed": [], + \}) + call s:add_definition('r', { \"type": 'variable', \"pcre2_regexp": '\bKEYWORD\s*=[^=><]', @@ -979,7 +1033,34 @@ call s:add_definition('perl', { \"pcre2_regexp": 'KEYWORD\s*=\s*', \"emacs_regexp": 'JJJ\s*=\s*', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["\\\$test = 1234"], + \"spec_success": ["$test = 1234"], + \"spec_failed": [], + \}) + +call s:add_definition('tcl', { + \"type": 'function', + \"pcre2_regexp": 'proc\s+KEYWORD\s*\{', + \"emacs_regexp": 'proc\s+JJJ\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["proc test{","proc test {"], + \"spec_failed": [], + \}) + +call s:add_definition('tcl', { + \"type": 'variable', + \"pcre2_regexp": 'set\s+KEYWORD', + \"emacs_regexp": 'set\s+JJJ', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["set test 1234"], + \"spec_failed": [], + \}) + +call s:add_definition('tcl', { + \"type": 'variable', + \"pcre2_regexp": '(variable|global)\s+KEYWORD', + \"emacs_regexp": '(variable|global)\s+JJJ', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["variable test","global test"], \"spec_failed": [], \}) @@ -1030,19 +1111,19 @@ call s:add_definition('php', { call s:add_definition('php', { \"type": 'variable', - \"pcre2_regexp": '(\s|->|\\\$|::)KEYWORD\s*=\s*', + \"pcre2_regexp": '(\s|->|\$|::)KEYWORD\s*=\s*', \"emacs_regexp": '(\s|->|\$|::)JJJ\s*=\s*', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["\\\$test = 1234","\\\$foo->test = 1234"], + \"spec_success": ["$test = 1234","$foo->test = 1234"], \"spec_failed": [], \}) call s:add_definition('php', { \"type": 'variable', - \"pcre2_regexp": '\*\s@property(-read|-write)?\s+([^ ]+\s+)&?\\\$KEYWORD(\s+|$)', - \"emacs_regexp": '\*\s@property(-read|-write)?\s+([^ ]+\s+)&?\\\$JJJ(\s+|$)', + \"pcre2_regexp": '\*\s@property(-read|-write)?\s+([^ ]+\s+)&?\$KEYWORD(\s+|$)', + \"emacs_regexp": '\*\s@property(-read|-write)?\s+([^ ]+\s+)&?\$JJJ(\s+|$)', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["/** @property string \\\$test","/** @property string \\\$test description for $test property"," * @property-read bool|bool \\\$test"," * @property-write \\ArrayObject \\\$test"], + \"spec_success": ["/** @property string $test","/** @property string $test description for $test property"," * @property-read bool|bool $test"," * @property-write \\ArrayObject $test"], \"spec_failed": [], \}) @@ -1066,10 +1147,10 @@ call s:add_definition('php', { call s:add_definition('php', { \"type": 'class', - \"pcre2_regexp": 'class\s*KEYWORD\s*(extends|implements|\{|$)', + \"pcre2_regexp": 'class\s*KEYWORD\s*(extends|implements|\{)', \"emacs_regexp": 'class\s*JJJ\s*(extends|implements|\{)', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["class test{","class test {", "class test\n{\n", "class test extends foo","class test implements foo"], + \"spec_success": ["class test{","class test {","class test extends foo","class test implements foo"], \"spec_failed": [], \}) @@ -1100,6 +1181,33 @@ call s:add_definition('faust', { \"spec_failed": [], \}) +call s:add_definition('fennel', { + \"type": 'variable', + \"pcre2_regexp": '\((local|var)\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\((local|var)\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(local test (foo)","(var test (foo)"], + \"spec_failed": [], + \}) + +call s:add_definition('fennel', { + \"type": 'function', + \"pcre2_regexp": '\(fn\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(fn\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(fn test [foo]"], + \"spec_failed": ["(fn test? [foo]"], + \}) + +call s:add_definition('fennel', { + \"type": 'function', + \"pcre2_regexp": '\(macro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(macro\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(macro test [foo]"], + \"spec_failed": [], + \}) + call s:add_definition('fortran', { \"type": 'variable', \"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+', @@ -1183,7 +1291,7 @@ call s:add_definition('go', { call s:add_definition('javascript', { \"type": 'function', - \"pcre2_regexp": '(service|factory)\s*\(\WKEYWORD\W', + \"pcre2_regexp": '(service|factory)\([''"]KEYWORD[''"]', \"emacs_regexp": '(service|factory)\([''"]JJJ[''"]', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"], @@ -1271,9 +1379,27 @@ call s:add_definition('javascript', { \"spec_failed": [], \}) +call s:add_definition('hcl', { + \"type": 'block', + \"pcre2_regexp": '(variable|output|module)\s*"KEYWORD"\s*\{', + \"emacs_regexp": '(variable|output|module)\s*"JJJ"\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["variable \"test\" {","output \"test\" {","module \"test\" {"], + \"spec_failed": [], + \}) + +call s:add_definition('hcl', { + \"type": 'block', + \"pcre2_regexp": '(data|resource)\s*"\w+"\s*"KEYWORD"\s*\{', + \"emacs_regexp": '(data|resource)\s*"\w+"\s*"JJJ"\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["data \"openstack_images_image_v2\" \"test\" {","resource \"google_compute_instance\" \"test\" {"], + \"spec_failed": [], + \}) + call s:add_definition('typescript', { \"type": 'function', - \"pcre2_regexp": '(service|factory)\(\WKEYWORD\W', + \"pcre2_regexp": '(service|factory)\([''"]KEYWORD[''"]', \"emacs_regexp": '(service|factory)\([''"]JJJ[''"]', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"], @@ -1419,7 +1545,7 @@ call s:add_definition('haskell', { \"type": 'module', \"pcre2_regexp": '^module\s+KEYWORD\s+', \"emacs_regexp": '^module\s+JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["module Test (exportA, exportB) where"], \"spec_failed": [], \}) @@ -1428,8 +1554,8 @@ call s:add_definition('haskell', { \"type": 'top level function', \"pcre2_regexp": '^\bKEYWORD(?!(\s+::))\s+((.|\s)*?)=\s+', \"emacs_regexp": '^\bJJJ(?!(\s+::))\s+((.|\s)*?)=\s+', - \"supports": ["ag", "rg"], - \"spec_success": ["test n = n * 2","test X{..} (Y a b c) \\n bcd \\n =\\n x * y","test ab cd e@Datatype {..} (Another thing, inTheRow) = \\n undefined","test = runRealBasedMode @ext @ctx identity identity","test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \\n undefined"], + \"supports": ["rg", "ag"], + \"spec_success": ["test n = n * 2","test X{..} (Y a b c) \n bcd \n =\n x * y","test ab cd e@Datatype {..} (Another thing, inTheRow) = \n undefined","test = runRealBasedMode @ext @ctx identity identity","test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \n undefined"], \"spec_failed": ["nottest n = n * 2","let testnot x y = x * y","test $ y z","let test a o = mda","test :: Sometype -> AnotherType aoeu kek = undefined"], \}) @@ -1437,7 +1563,7 @@ call s:add_definition('haskell', { \"type": 'type-like', \"pcre2_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+KEYWORD\s+', \"emacs_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["newtype Test a = Something { b :: Kek }","data Test a b = Somecase a | Othercase b","type family Test (x :: *) (xs :: [*]) :: Nat where","data family Test ","type Test = TestAlias"], \"spec_failed": ["newtype NotTest a = NotTest (Not a)","data TestNot b = Aoeu"], \}) @@ -1446,7 +1572,7 @@ call s:add_definition('haskell', { \"type": '(data)type constructor 1', \"pcre2_regexp": '(data|newtype)\s{1,3}(?!KEYWORD\s+)([^=]{1,40})=((\s{0,3}KEYWORD\s+)|([^=]{0,500}?((?\s*)?KEYWORD\s+', \"emacs_regexp": '^class\s+(.+=>\s*)?JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["class (Constr1 m, Constr 2) => Test (Kek a) where","class Test (Veryovka a) where "], \"spec_failed": ["class Test2 (Kek a) where","class MakeTest (AoeuTest x y z) where"], \}) @@ -1579,7 +1705,7 @@ call s:add_definition('lua', { call s:add_definition('rust', { \"type": 'variable', - \"pcre2_regexp": '\blet\s+(\([^=\n]*)?(mut\s+)?KEYWORD([^=\n]*\))?(:\s*[^=\n]+)?\s*=\s*[^=\n]+', + \"pcre2_regexp": '\blet\s+(\([^=\n]*)?(muts+)?KEYWORD([^=\n]*\))?(:\s*[^=\n]+)?\s*=\s*[^=\n]+', \"emacs_regexp": '\blet\s+(\([^=\n]*)?(muts+)?JJJ([^=\n]*\))?(:\s*[^=\n]+)?\s*=\s*[^=\n]+', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["let test = 1234;","let test: u32 = 1234;","let test: Vec = Vec::new();","let mut test = 1234;","let mut test: Vec = Vec::new();","let (a, test, b) = (1, 2, 3);","let (a, mut test, mut b) = (1, 2, 3);","let (mut a, mut test): (u32, usize) = (1, 2);"], @@ -1939,7 +2065,7 @@ call s:add_definition('vhdl', { call s:add_definition('tex', { \"type": 'command', - \"pcre2_regexp": '\\\\.*newcommand\*?\s*\{\s*(\\\\)KEYWORD\s*}', + \"pcre2_regexp": '\\.*newcommand\*?\s*\{\s*(\\)KEYWORD\s*}', \"emacs_regexp": '\\.*newcommand\*?\s*\{\s*(\\)JJJ\s*}', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["\\newcommand{\\test}","\\renewcommand{\\test}","\\renewcommand*{\\test}","\\newcommand*{\\test}","\\renewcommand{ \\test }"], @@ -1948,7 +2074,7 @@ call s:add_definition('tex', { call s:add_definition('tex', { \"type": 'command', - \"pcre2_regexp": '\\\\.*newcommand\*?\s*(\\\\)KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"pcre2_regexp": '\\.*newcommand\*?\s*(\\)KEYWORD($|[^a-zA-Z0-9\?\*-])', \"emacs_regexp": '\\.*newcommand\*?\s*(\\)JJJ\j', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["\\newcommand\\test {}","\\renewcommand\\test{}","\\newcommand \\test"], @@ -1957,7 +2083,7 @@ call s:add_definition('tex', { call s:add_definition('tex', { \"type": 'length', - \"pcre2_regexp": '\\\\(s)etlength\s*\{\s*(\\\\)KEYWORD\s*}', + \"pcre2_regexp": '\\(s)etlength\s*\{\s*(\\)KEYWORD\s*}', \"emacs_regexp": '\\(s)etlength\s*\{\s*(\\)JJJ\s*}', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["\\setlength { \\test}","\\setlength{\\test}","\\setlength{\\test}{morecommands}"], @@ -1966,7 +2092,7 @@ call s:add_definition('tex', { call s:add_definition('tex', { \"type": 'counter', - \"pcre2_regexp": '\\\\newcounter\{\s*KEYWORD\s*}', + \"pcre2_regexp": '\\newcounter\{\s*KEYWORD\s*}', \"emacs_regexp": '\\newcounter\{\s*JJJ\s*}', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["\\newcounter{test}"], @@ -2054,6 +2180,24 @@ call s:add_definition('kotlin', { \"spec_failed": [], \}) +call s:add_definition('zig', { + \"type": 'function', + \"pcre2_regexp": 'fn\s+KEYWORD\b', + \"emacs_regexp": 'fn\s+JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["fn test() void {","fn test(a: i32) i32 {","pub fn test(a: i32) i32 {","export fn test(a: i32) i32 {","extern \"c\" fn test(a: i32) i32 {","inline fn test(a: i32) i32 {"], + \"spec_failed": [], + \}) + +call s:add_definition('zig', { + \"type": 'variable', + \"pcre2_regexp": '(var|const)\s+KEYWORD\b', + \"emacs_regexp": '(var|const)\s+JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["const test: i32 = 3;","var test: i32 = 3;","pub const test: i32 = 3;"], + \"spec_failed": [], + \}) + call s:add_definition('protobuf', { \"type": 'message', \"pcre2_regexp": 'message\s+KEYWORD\s*\{', @@ -2071,3 +2215,30 @@ call s:add_definition('protobuf', { \"spec_success": ["enum test{","enum test {"], \"spec_failed": [], \}) + +call s:add_definition('apex', { + \"type": 'function', + \"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(', + \"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(', + \"supports": ["ag", "rg"], + \"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()","private foo[] test()"], + \"spec_failed": ["test()","testnot()","blah = new test()","foo bar = test()"], + \}) + +call s:add_definition('apex', { + \"type": 'variable', + \"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+', + \"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["int test = 1234"], + \"spec_failed": ["if test == 1234:","int nottest = 44"], + \}) + +call s:add_definition('apex', { + \"type": 'type', + \"pcre2_regexp": '(class|interface)\s*KEYWORD\b', + \"emacs_regexp": '(class|interface)\s*JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["class test:","public class test implements Something"], + \"spec_failed": ["class testnot:","public class testnot implements Something"], + \}) diff --git a/autoload/search.vim b/autoload/search.vim index bd95509..cdd4709 100644 --- a/autoload/search.vim +++ b/autoload/search.vim @@ -292,7 +292,7 @@ fu! search#RunRegexpSpecs() abort \ . test_re . "\"" endif - let raw_results = system(cmd) + let raw_results = system(shellescape(cmd)) if index(invalid_exist_statues[spec_type], v:shell_error) != -1 call add(errors, 'FAILED ' . engine . ' ' . lang . ' ' . spec_type . ' -- result: ' . string(raw_results) . "; spec: " . string(spec_string) . '; re: ' . string(test_re)) diff --git a/generator/.ruby-version b/generator/.ruby-version new file mode 100644 index 0000000..fd2a018 --- /dev/null +++ b/generator/.ruby-version @@ -0,0 +1 @@ +3.1.0 diff --git a/generator/Gemfile b/generator/Gemfile index de379fc..b31af5f 100644 --- a/generator/Gemfile +++ b/generator/Gemfile @@ -4,3 +4,5 @@ source "https://rubygems.org" git_source(:github) {|repo_name| "https://github.com/#{repo_name}" } gem "sxp" +gem "rake" +gem "http" diff --git a/generator/Gemfile.lock b/generator/Gemfile.lock index 97080b7..b9fd610 100644 --- a/generator/Gemfile.lock +++ b/generator/Gemfile.lock @@ -1,21 +1,45 @@ GEM remote: https://rubygems.org/ specs: - concurrent-ruby (1.1.6) - hamster (3.0.0) - concurrent-ruby (~> 1.0) + addressable (2.8.1) + public_suffix (>= 2.0.2, < 6.0) + domain_name (0.5.20190701) + unf (>= 0.0.5, < 1.0.0) + ffi (1.15.5) + ffi-compiler (1.0.1) + ffi (>= 1.0.0) + rake + http (5.1.0) + addressable (~> 2.8) + http-cookie (~> 1.0) + http-form_data (~> 2.2) + llhttp-ffi (~> 0.4.0) + http-cookie (1.0.5) + domain_name (~> 0.5) + http-form_data (2.3.0) link_header (0.0.8) - rdf (3.1.1) - hamster (~> 3.0) + llhttp-ffi (0.4.0) + ffi-compiler (~> 1.0) + rake (~> 13.0) + matrix (0.4.2) + public_suffix (5.0.0) + rake (13.0.6) + rdf (3.2.9) link_header (~> 0.0, >= 0.0.8) - sxp (1.1.0) - rdf (~> 3.1) + sxp (1.2.2) + matrix + rdf (~> 3.2) + unf (0.1.4) + unf_ext + unf_ext (0.0.8.2) PLATFORMS - ruby + x86_64-darwin-21 DEPENDENCIES + http + rake sxp BUNDLED WITH - 1.17.2 + 2.3.3 diff --git a/generator/README.md b/generator/README.md new file mode 100644 index 0000000..a0fb8b8 --- /dev/null +++ b/generator/README.md @@ -0,0 +1,24 @@ +# any-jump lang map build process + +## source for lang definition +https://github.com/jacktasia/dumb-jump/blob/master/dumb-jump.el + +## step 1: download .el file and extract definitions +``` +bundle exec rake download +``` + +## step 2: generate lang_map.el +``` +bundle exec rake generate +``` + +## step 3: install lang_map.el to autoload/lang_map.vim +``` +bundle exec rake install +``` + +## all steps together: +``` +bundle exec rake update +``` diff --git a/generator/Rakefile b/generator/Rakefile new file mode 100644 index 0000000..4ecd5d1 --- /dev/null +++ b/generator/Rakefile @@ -0,0 +1,40 @@ +require 'rubygems' +require 'bundler/setup' + +require './lib/download.rb' +require './lib/generate.rb' + +task default: [:update] + +task :download do + result = Download.new.call + file = File.new('./lang_map_downloaded.el', 'w') + bytes = file.write(result) + file.close + + puts "Downloading and extracting lisp language map completed: #{bytes} bytes" +end + +task :generate do + in_file_path = './lang_map_downloaded.el' || ENV['IN'] + out_file_path = './lang_map_generated.vim' || ENV['OUT'] + + Generate.new(in_file_path, out_file_path).call + + puts "lang map generated at #{out_file_path}" +end + +task :install do + require 'fileutils' + + in_file_path = './lang_map_generated.vim' || ENV['IN'] + out_file_path = '../autoload/lang_map.vim' || ENV['OUT'] + + FileUtils.cp(in_file_path, out_file_path) + + puts "lang map installed at #{out_file_path}" +end + +task :update => [ :download, :generate, :install ] do + puts "update finished" +end diff --git a/generator/lang_map.rb b/generator/lang_map.rb deleted file mode 100644 index 8830c08..0000000 --- a/generator/lang_map.rb +++ /dev/null @@ -1,142 +0,0 @@ -require 'rubygems' -require 'bundler/setup' - -require 'json' -require 'sxp' - -unless ENV["IN"] - throw "input file not specified via IN" -end - -unless ENV["OUT"] - throw "output file not specified via OUT" -end - -unless File.exists?(ENV['IN']) - throw "file not found -> #{ENV['IN']}" -end - -lisp = File.read(ENV['IN']) -sexps = SXP::Reader::Basic.read(lisp) - -unless sexps.is_a?(Array) - raise RuntimeError, "No sexps found" -end - -puts "Total sexps rules to import: #{ sexps.count.to_s }\n\n" - -LOOKUP_KEYS_TRANSFORM = { - :":type" => :type, - :":supports" => :supports, - :":language" => :language, - :":regex" => :emacs_regexp, - :":tests" => :spec_success, - :":not" => :spec_failed -} - -LOOKUP_KEYS = LOOKUP_KEYS_TRANSFORM.keys -COMMENT_START = :";;" - -def process_definition(def_array) - return unless def_array.is_a?(Array) - result = {} - - next_type = nil - - for e in def_array - # comment or key definition - if e == COMMENT_START - next_type = :comment - next - elsif LOOKUP_KEYS.include?(e) - next_type = LOOKUP_KEYS_TRANSFORM[e] - next - end - - # comment body or key value - if next_type == :comment - next - elsif next_type != nil - result[next_type] = e - next_type = nil - next - end - end - - return result -end - -def definitions_viml - r = <<~STR - " NOTES: - " - all language regexps ported from https://github.com/jacktasia/dumb-jump/blob/master/dumb-jump.el - - let s:definitions = {} - - fu! s:add_definition(lang, definition) abort - if !has_key(s:definitions, a:lang) - let s:definitions[a:lang] = [] - endif - - call add(s:definitions[a:lang], a:definition) - endfu - - fu! lang_map#find_definitions(language) abort - if !lang_map#lang_exists(a:language) - return - endif - - return s:definitions[a:language] - endfu - - fu! lang_map#definitions() abort - return s:definitions - endfu - - fu! lang_map#lang_exists(language) abort - return has_key(s:definitions, a:language) - endfu - STR - - return r -end - -def pcre2_regexp(string) - string = string.dup.to_s - - string.gsub!('JJJ', 'KEYWORD') - string.gsub!('\\j', '($|[^a-zA-Z0-9\\?\\*-])') - - return string -end - -def convert_definition_to_viml(hash = {}) - # puts hash[:emacs_regexp].dump - r = "\n" - r << "call s:add_definition('#{hash[:language]}', {\n" - r << "\t" + '\"type": ' + "'" + hash[:type] + "',\n" - r << "\t" + '\"pcre2_regexp": ' + "'" + pcre2_regexp(hash[:emacs_regexp]) + "',\n" - r << "\t" + '\"emacs_regexp": ' + "'" + hash[:emacs_regexp].to_s + "',\n" - r << "\t" + '\"supports": ' + hash[:supports].to_s + ",\n" - r << "\t" + '\"spec_success": ' + hash[:spec_success].to_a.to_json + ",\n" - r << "\t" + '\"spec_failed": ' + hash[:spec_failed].to_a.to_json + ",\n" - r << "\t" + "\\})\n" - - return r -end - -vimscript = "" -vimscript << definitions_viml() - -sexps.each_with_index do |sexp, i| - result = process_definition(sexp) - next unless result - next if result.empty? - - viml_definition = convert_definition_to_viml(result) - vimscript << viml_definition -end - -outfile = File.new(ENV['OUT'], 'w') -outfile.print(vimscript) -outfile.close diff --git a/generator/lang_map.el b/generator/lang_map_downloaded.el similarity index 88% rename from generator/lang_map.el rename to generator/lang_map_downloaded.el index 3711d3b..c7846a0 100644 --- a/generator/lang_map.el +++ b/generator/lang_map_downloaded.el @@ -5,6 +5,12 @@ :not ("(defun test-asdf (blah)" "(defun test-blah\n" "(cl-defun test-asdf (blah)" "(cl-defun test-blah\n" "(defun tester (blah)" "(defun test? (blah)" "(defun test- (blah)")) + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "elisp" + :regex "\\\(defmacro\\s+JJJ\\j" + :tests ("(defmacro test (blah)" "(defmacro test\n") + :not ("(defmacro test-asdf (blah)" "(defmacro test-blah\n" "(defmacro tester (blah)" + "(defmacro test? (blah)" "(defmacro test- (blah)")) + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "elisp" :regex "\\\(defvar\\b\\s*JJJ\\j" :tests ("(defvar test " "(defvar test\n") @@ -119,8 +125,8 @@ ;; c++ (:type "function" :supports ("ag" "rg" "git-grep") :language "c++" - :regex "\\bJJJ(\\s|\\))*\\((\\w|[,&*.<>]|\\s)*(\\))\\s*(const|->|\\{|$)|typedef\\s+(\\w|[(*]|\\s)+JJJ(\\)|\\s)*\\(" - :tests ("int test(){" "my_struct (*test)(int a, int b){" "auto MyClass::test ( Builder& reference, ) -> decltype( builder.func() ) {" "int test( int *random_argument) const {" "test::test() {" "typedef int (*test)(int);") + :regex "\\bJJJ(\\s|\\))*\\((\\w|[,&*.<>:]|\\s)*(\\))\\s*(const|->|\\{|$)|typedef\\s+(\\w|[(*]|\\s)+JJJ(\\)|\\s)*\\(" + :tests ("int test(){" "my_struct (*test)(int a, int b){" "auto MyClass::test ( Builder::Builder& reference, ) -> decltype( builder.func() ) {" "int test( int *random_argument) const {" "test::test() {" "typedef int (*test)(int);") :not ("return test();)" "int test(a, b);" "if( test() ) {" "else test();")) ;; (:type "variable" :supports ("grep") :language "c++" @@ -221,17 +227,24 @@ ;; swift (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "swift" :regex "(let|var)\\s*JJJ\\s*(=|:)[^=:\\n]+" - :tests ("let test = 1234" "var test = 1234" "private lazy var test: UITapGestureRecognizer") :not ("if test == 1234:")) + :tests ("let test = 1234" "var test = 1234" "private lazy var test: UITapGestureRecognizer") + :not ("if test == 1234:")) (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "swift" - :regex "func\\s*JJJ\\b\\s*\\\(" - :tests ("func test(asdf)" "func test()") + :regex "func\\s+JJJ\\b\\s*(<[^>]*>)?\\s*\\(" + :tests ("func test(asdf)" "func test()" "func test()") :not ("func testnot(asdf)" "func testnot()")) (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "swift" - :regex "(class|struct)\\s*JJJ\\b\\s*?" - :tests ("class test:" "class test: UIWindow") - :not ("class testnot:" "class testnot(object):")) + :regex "(class|struct|protocol|enum)\\s+JJJ\\b\\s*?" + :tests ("struct test" "struct test: Codable" "struct test" + "class test:" "class test: UIWindow" "class test") + :not ("class testnot:" "class testnot(object):" "struct testnot(object)")) + + (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "swift" + :regex "(typealias)\\s+JJJ\\b\\s*?=" + :tests ("typealias test =") + :not ("typealias testnot")) ;; c# (:type "function" :supports ("ag" "rg") :language "csharp" @@ -348,7 +361,7 @@ :not ("for test = 1:2:" "_test = 1234")) (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "matlab" - :regex "^\\s*function\\s*[^=]+\\s*=\\s*JJJ\\b" + :regex "^\\s*function\\s*[^=]+\\s*=\\s*JJJ\\b" :tests ("\tfunction y = test(asdf)" "function x = test()" "function [x, losses] = test(A, y, lambda, method, qtile)") :not ("\tfunction testnot(asdf)" "function testnot()")) @@ -359,18 +372,18 @@ ;; nim (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "nim" - :regex "(const|let|var)\\s*JJJ\\s*(=|:)[^=:\\n]+" - :tests ("let test = 1234" "var test = 1234" "var test: Stat" "const test = 1234") + :regex "(const|let|var)\\s*JJJ\\*?\\s*(=|:)[^=:\\n]+" + :tests ("let test = 1234" "var test = 1234" "var test: Stat" "const test = 1234" "const test* = 1234") :not ("if test == 1234:")) (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "nim" - :regex "(proc|func|macro|template)\\s*`?JJJ`?\\b\\s*\\\(" - :tests ("\tproc test(asdf)" "proc test()" "func test()" "macro test()" "template test()") + :regex "(proc|func|macro|template)\\s*`?JJJ`?\\b\\*?\\s*\\\(" + :tests ("\tproc test(asdf)" "proc test()" "func test()" "macro test()" "template test()" "proc test*()") :not ("\tproc testnot(asdf)" "proc testnot()")) (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "nim" - :regex "type\\s*JJJ\\b\\s*(\\{[^}]+\\})?\\s*=\\s*\\w+" - :tests ("type test = object" "type test {.pure.} = enum") + :regex "type\\s*JJJ\\b\\*?\\s*(\\{[^}]+\\})?\\s*=\\s*\\w+" + :tests ("type test = object" "type test {.pure.} = enum" "type test* = ref object") :not ("type testnot = object")) ;; nix @@ -496,6 +509,23 @@ :regex "object\\s*JJJ\\s*\\\(?" :tests ("object test(object)")) + ;; solidity + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "solidity" + :regex "function\\s*JJJ\\s*\\\(" + :tests ("function test() internal" "function test (uint x, address y)" "function test() external")) + + (:type "modifier" :supports ("ag" "grep" "rg" "git-grep") :language "solidity" + :regex "modifier\\s*JJJ\\s*\\\(" + :tests ("modifier test()" "modifier test ()")) + + (:type "event" :supports ("ag" "grep" "rg" "git-grep") :language "solidity" + :regex "event\\s*JJJ\\s*\\\(" + :tests ("event test();" "event test (uint indexed x)" "event test(uint x, address y)")) + + (:type "error" :supports ("ag" "grep" "rg" "git-grep") :language "solidity" + :regex "error\\s*JJJ\\s*\\\(" + :tests ("error test();" "error test (uint x)" "error test(uint x, address y)")) + ;; R (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "r" :regex "\\bJJJ\\s*=[^=><]" :tests ("test = 1234") :not ("if (test == 1234)")) @@ -514,6 +544,19 @@ :regex "JJJ\\s*=\\s*" :tests ("$test = 1234")) + ;; Tcl + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "tcl" + :regex "proc\\s+JJJ\\s*\\{" + :tests ("proc test{" "proc test {")) + + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "tcl" + :regex "set\\s+JJJ" + :tests ("set test 1234")) + + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "tcl" + :regex "(variable|global)\\s+JJJ" + :tests ("variable test" "global test")) + ;; shell (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "shell" :regex "function\\s*JJJ\\s*" @@ -535,7 +578,7 @@ :tests ("function test()" "function test ()")) (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "php" - :regex "\\*\\s@method\\s+[^ ]+\\s+JJJ\\(" + :regex "\\*\\s@method\\s+[^ \t]+\\s+JJJ\\(" :tests ("/** @method string|false test($a)" " * @method bool test()")) (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "php" @@ -543,7 +586,7 @@ :tests ("$test = 1234" "$foo->test = 1234")) (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "php" - :regex "\\*\\s@property(-read|-write)?\\s+([^ ]+\\s+)&?\\$JJJ(\\s+|$)" + :regex "\\*\\s@property(-read|-write)?\\s+([^ \t]+\\s+)&?\\$JJJ(\\s+|$)" :tests ("/** @property string $test" "/** @property string $test description for $test property" " * @property-read bool|bool $test" " * @property-write \\ArrayObject $test")) (:type "trait" :supports ("ag" "grep" "rg" "git-grep") :language "php" :regex "trait\\s*JJJ\\s*\\\{" @@ -571,6 +614,21 @@ :regex "\\bJJJ\(\\\(.+\\\)\)*\\s*=" :tests ("test = osc + 0.5;" "test(freq) = osc(freq) + 0.5;")) + ;; fennel + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "fennel" + :regex "\\((local|var)\\s+JJJ\\j" + :tests ("(local test (foo)" + "(var test (foo)")) + + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fennel" + :regex "\\(fn\\s+JJJ\\j" + :tests ("(fn test [foo]") + :not ("(fn test? [foo]")) + + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "fennel" + :regex "\\(macro\\s+JJJ\\j" + :tests ("(macro test [foo]")) + ;; fortran (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "fortran" :regex "\\s*\\bJJJ\\s*=[^=\\n]+" @@ -659,6 +717,18 @@ :regex "\\bJJJ\\s*=\\s*function\\s*\\\(" :tests ("test = function()")) + ;; hcl terraform + (:type "block" :supports ("ag" "grep" "rg" "git-grep") :language "hcl" + :regex "(variable|output|module)\\s*\"JJJ\"\\s*\\\{" + :tests ("variable \"test\" {" + "output \"test\" {" + "module \"test\" {")) + + (:type "block" :supports ("ag" "grep" "rg" "git-grep") :language "hcl" + :regex "(data|resource)\\s*\"\\w+\"\\s*\"JJJ\"\\s*\\\{" + :tests ("data \"openstack_images_image_v2\" \"test\" {" + "resource \"google_compute_instance\" \"test\" {")) + ;; typescript (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "typescript" :regex "(service|factory)\\\(['\"]JJJ['\"]" :tags ("angular") @@ -730,12 +800,12 @@ :tests ("type test" "immutable test" "abstract test <:Testable" )) ;; haskell - (:type "module" :supports ("ag" "rg") :language "haskell" + (:type "module" :supports ("ag") :language "haskell" :regex "^module\\s+JJJ\\s+" :tests ("module Test (exportA, exportB) where")) - ; TODO Doesn't support any '=' in arguments. E.g. 'foo A{a = b,..} = bar'. - (:type "top level function" :supports ("ag" "rg") :language "haskell" + ; TODO Doesn't support any '=' in arguments. E.g. 'foo A{a = b,..} = bar'. + (:type "top level function" :supports ("ag") :language "haskell" :regex "^\\bJJJ(?!(\\s+::))\\s+((.|\\s)*?)=\\s+" :tests ("test n = n * 2" "test X{..} (Y a b c) \n bcd \n =\n x * y" @@ -746,7 +816,7 @@ "let testnot x y = x * y" "test $ y z" "let test a o = mda" "test :: Sometype -> AnotherType aoeu kek = undefined")) - (:type "type-like" :supports ("ag" "rg") :language "haskell" + (:type "type-like" :supports ("ag") :language "haskell" :regex "^\\s*((data(\\s+family)?)|(newtype)|(type(\\s+family)?))\\s+JJJ\\s+" :tests ("newtype Test a = Something { b :: Kek }" "data Test a b = Somecase a | Othercase b" @@ -756,8 +826,8 @@ :not ("newtype NotTest a = NotTest (Not a)" "data TestNot b = Aoeu")) - ; datatype contstuctor that doesn't match type definition. - (:type "(data)type constructor 1" :supports ("ag" "rg") :language "haskell" + ; datatype contstuctor that doesn't match type definition. + (:type "(data)type constructor 1" :supports ("ag") :language "haskell" :regex "(data|newtype)\\s{1,3}(?!JJJ\\s+)([^=]{1,40})=((\\s{0,3}JJJ\\s+)|([^=]{0,500}?((?\\s*)?JJJ\\s+" :tests ( "class (Constr1 m, Constr 2) => Test (Kek a) where" @@ -1082,7 +1152,7 @@ :tests ("function Matrix test ;" "function Matrix test;") :not ("function test blah")) - ;; matches SV class handle declarations + ;; matches SV class handle declarations (:type "function" :supports ("ag" "rg" "git-grep") :language "systemverilog" :regex "^\\s*[^\\s]*\\s*[^\\s]+\\s+\\bJJJ\\b" :tests ("some_class_name test" " another_class_name test ;" "some_class test[];" "some_class #(1) test") @@ -1141,19 +1211,19 @@ ;; f# (:type "variable" :supports ("ag" "grep" "git-grep") :language "fsharp" - :regex "let\\s+JJJ\\b.*\\\=" - :tests ("let test = 1234" "let test() = 1234" "let test abc def = 1234") - :not ("let testnot = 1234" "let testnot() = 1234" "let testnot abc def = 1234")) + :regex "let\\s+JJJ\\b.*\\\=" + :tests ("let test = 1234" "let test() = 1234" "let test abc def = 1234") + :not ("let testnot = 1234" "let testnot() = 1234" "let testnot abc def = 1234")) (:type "interface" :supports ("ag" "grep" "git-grep") :language "fsharp" - :regex "member(\\b.+\\.|\\s+)JJJ\\b.*\\\=" - :tests ("member test = 1234" "member this.test = 1234") - :not ("member testnot = 1234" "member this.testnot = 1234")) + :regex "member(\\b.+\\.|\\s+)JJJ\\b.*\\\=" + :tests ("member test = 1234" "member this.test = 1234") + :not ("member testnot = 1234" "member this.testnot = 1234")) (:type "type" :supports ("ag" "grep" "git-grep") :language "fsharp" - :regex "type\\s+JJJ\\b.*\\\=" - :tests ("type test = 1234") - :not ("type testnot = 1234")) + :regex "type\\s+JJJ\\b.*\\\=" + :tests ("type test = 1234") + :not ("type testnot = 1234")) ;; kotlin (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "kotlin" @@ -1167,6 +1237,22 @@ :regex "(class|interface)\\s*JJJ\\b" :tests ("class test" "class test : SomeInterface" "interface test")) + ;; zig + (:type "function" :supports ("ag" "grep" "rg" "git-grep") :language "zig" + :regex "fn\\s+JJJ\\b" + :tests ("fn test() void {" + "fn test(a: i32) i32 {" + "pub fn test(a: i32) i32 {" + "export fn test(a: i32) i32 {" + "extern \"c\" fn test(a: i32) i32 {" + "inline fn test(a: i32) i32 {")) + + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "zig" + :regex "(var|const)\\s+JJJ\\b" + :tests ("const test: i32 = 3;" + "var test: i32 = 3;" + "pub const test: i32 = 3;")) + ;; protobuf (:type "message" :supports ("ag" "grep" "rg" "git-grep") :language "protobuf" :regex "message\\s+JJJ\\s*\\\{" @@ -1174,4 +1260,20 @@ (:type "enum" :supports ("ag" "grep" "rg" "git-grep") :language "protobuf" :regex "enum\\s+JJJ\\s*\\\{" - :tests ("enum test{" "enum test {"))) + :tests ("enum test{" "enum test {")) + + ;; apex (literally the same regexes as java) + (:type "function" :supports ("ag" "rg") :language "apex" + :regex "^\\s*(?:[\\w\\[\\]]+\\s+){1,3}JJJ\\s*\\\(" + :tests ("int test()" "int test(param)" "static int test()" "static int test(param)" + "public static MyType test()" "private virtual SomeType test(param)" "static int test()" + "private foo[] test()") + :not ("test()" "testnot()" "blah = new test()" "foo bar = test()")) + + (:type "variable" :supports ("ag" "grep" "rg" "git-grep") :language "apex" + :regex "\\s*\\bJJJ\\s*=[^=\\n)]+" :tests ("int test = 1234") :not ("if test == 1234:" "int nottest = 44")) + + (:type "type" :supports ("ag" "grep" "rg" "git-grep") :language "apex" + :regex "(class|interface)\\s*JJJ\\b" + :tests ("class test:" "public class test implements Something") + :not ("class testnot:" "public class testnot implements Something"))) \ No newline at end of file diff --git a/generator/lang_map_generated.vim b/generator/lang_map_generated.vim index 2043c1d..fbb6406 100644 --- a/generator/lang_map_generated.vim +++ b/generator/lang_map_generated.vim @@ -3,6 +3,12 @@ let s:definitions = {} +" map any-language to concrete internal s:definitions[language] +let s:filetypes_proxy = { + \"javascriptreact": "javascript", + \"c": "cpp", + \} + fu! s:add_definition(lang, definition) abort if !has_key(s:definitions, a:lang) let s:definitions[a:lang] = [] @@ -27,6 +33,20 @@ fu! lang_map#lang_exists(language) abort return has_key(s:definitions, a:language) endfu +fu! lang_map#get_language_from_filetype(ft) abort + if has_key(s:filetypes_proxy, a:ft) + let maybe_lan = s:filetypes_proxy[a:ft] + else + let maybe_lan = a:ft + endif + + if lang_map#lang_exists(maybe_lan) + return maybe_lan + else + return 0 + endif +endfu + call s:add_definition('elisp', { \"type": 'function', \"pcre2_regexp": '\((defun|cl-defun)\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', @@ -36,6 +56,15 @@ call s:add_definition('elisp', { \"spec_failed": ["(defun test-asdf (blah)","(defun test-blah\n","(cl-defun test-asdf (blah)","(cl-defun test-blah\n","(defun tester (blah)","(defun test? (blah)","(defun test- (blah)"], \}) +call s:add_definition('elisp', { + \"type": 'function', + \"pcre2_regexp": '\(defmacro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(defmacro\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(defmacro test (blah)","(defmacro test\n"], + \"spec_failed": ["(defmacro test-asdf (blah)","(defmacro test-blah\n","(defmacro tester (blah)","(defmacro test? (blah)","(defmacro test- (blah)"], + \}) + call s:add_definition('elisp', { \"type": 'variable', \"pcre2_regexp": '\(defvar\b\s*KEYWORD($|[^a-zA-Z0-9\?\*-])', @@ -234,16 +263,16 @@ call s:add_definition('scheme', { \"spec_failed": ["(define foo test","(define (test foo","(define (test)"], \}) -call s:add_definition('c++', { +call s:add_definition('cpp', { \"type": 'function', - \"pcre2_regexp": '\bKEYWORD(\s|\))*\((\w|[,&*.<>]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+KEYWORD(\)|\s)*\(', - \"emacs_regexp": '\bJJJ(\s|\))*\((\w|[,&*.<>]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+JJJ(\)|\s)*\(', + \"pcre2_regexp": '\bKEYWORD(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+KEYWORD(\)|\s)*\(', + \"emacs_regexp": '\bJJJ(\s|\))*\((\w|[,&*.<>:]|\s)*(\))\s*(const|->|\{|$)|typedef\s+(\w|[(*]|\s)+JJJ(\)|\s)*\(', \"supports": ["ag", "rg", "git-grep"], - \"spec_success": ["int test(){","my_struct (*test)(int a, int b){","auto MyClass::test ( Builder& reference, ) -> decltype( builder.func() ) {","int test( int *random_argument) const {","test::test() {","typedef int (*test)(int);"], + \"spec_success": ["int test(){","my_struct (*test)(int a, int b){","auto MyClass::test ( Builder::Builder& reference, ) -> decltype( builder.func() ) {","int test( int *random_argument) const {","test::test() {","typedef int (*test)(int);"], \"spec_failed": ["return test();)","int test(a, b);","if( test() ) {","else test();"], \}) -call s:add_definition('c++', { +call s:add_definition('cpp', { \"type": 'variable', \"pcre2_regexp": '(\b\w+|[,>])([*&]|\s)+KEYWORD\s*(\[([0-9]|\s)*\])*\s*([=,){;]|:\s*[0-9])|#define\s+KEYWORD\b', \"emacs_regexp": '(\b\w+|[,>])([*&]|\s)+JJJ\s*(\[([0-9]|\s)*\])*\s*([=,){;]|:\s*[0-9])|#define\s+JJJ\b', @@ -252,7 +281,7 @@ call s:add_definition('c++', { \"spec_failed": [], \}) -call s:add_definition('c++', { +call s:add_definition('cpp', { \"type": 'variable', \"pcre2_regexp": '\b(?!(class\b|struct\b|return\b|else\b|delete\b))(\w+|[,>])([*&]|\s)+KEYWORD\s*(\[(\d|\s)*\])*\s*([=,(){;]|:\s*\d)|#define\s+KEYWORD\b', \"emacs_regexp": '\b(?!(class\b|struct\b|return\b|else\b|delete\b))(\w+|[,>])([*&]|\s)+JJJ\s*(\[(\d|\s)*\])*\s*([=,(){;]|:\s*\d)|#define\s+JJJ\b', @@ -261,7 +290,7 @@ call s:add_definition('c++', { \"spec_failed": ["return test;","#define NOT test","else test=2;"], \}) -call s:add_definition('c++', { +call s:add_definition('cpp', { \"type": 'type', \"pcre2_regexp": '\b(class|struct|enum|union)\b\s*KEYWORD\b\s*(final\s*)?(:((\s*\w+\s*::)*\s*\w*\s*?\s*,*)+)?((\{|$))|}\s*KEYWORD\b\s*;', \"emacs_regexp": '\b(class|struct|enum|union)\b\s*JJJ\b\s*(final\s*)?(:((\s*\w+\s*::)*\s*\w*\s*?\s*,*)+)?((\{|$))|}\s*JJJ\b\s*;', @@ -434,20 +463,29 @@ call s:add_definition('swift', { call s:add_definition('swift', { \"type": 'function', - \"pcre2_regexp": 'func\s*KEYWORD\b\s*\(', - \"emacs_regexp": 'func\s*JJJ\b\s*\(', + \"pcre2_regexp": 'func\s+KEYWORD\b\s*(<[^>]*>)?\s*\(', + \"emacs_regexp": 'func\s+JJJ\b\s*(<[^>]*>)?\s*\(', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["func test(asdf)","func test()"], + \"spec_success": ["func test(asdf)","func test()","func test()"], \"spec_failed": ["func testnot(asdf)","func testnot()"], \}) call s:add_definition('swift', { \"type": 'type', - \"pcre2_regexp": '(class|struct)\s*KEYWORD\b\s*?', - \"emacs_regexp": '(class|struct)\s*JJJ\b\s*?', + \"pcre2_regexp": '(class|struct|protocol|enum)\s+KEYWORD\b\s*?', + \"emacs_regexp": '(class|struct|protocol|enum)\s+JJJ\b\s*?', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["class test:","class test: UIWindow"], - \"spec_failed": ["class testnot:","class testnot(object):"], + \"spec_success": ["struct test","struct test: Codable","struct test","class test:","class test: UIWindow","class test"], + \"spec_failed": ["class testnot:","class testnot(object):","struct testnot(object)"], + \}) + +call s:add_definition('swift', { + \"type": 'type', + \"pcre2_regexp": '(typealias)\s+KEYWORD\b\s*?=', + \"emacs_regexp": '(typealias)\s+JJJ\b\s*?=', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["typealias test ="], + \"spec_failed": ["typealias testnot"], \}) call s:add_definition('csharp', { @@ -668,28 +706,28 @@ call s:add_definition('matlab', { call s:add_definition('nim', { \"type": 'variable', - \"pcre2_regexp": '(const|let|var)\s*KEYWORD\s*(=|:)[^=:\n]+', - \"emacs_regexp": '(const|let|var)\s*JJJ\s*(=|:)[^=:\n]+', + \"pcre2_regexp": '(const|let|var)\s*KEYWORD\*?\s*(=|:)[^=:\n]+', + \"emacs_regexp": '(const|let|var)\s*JJJ\*?\s*(=|:)[^=:\n]+', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["let test = 1234","var test = 1234","var test: Stat","const test = 1234"], + \"spec_success": ["let test = 1234","var test = 1234","var test: Stat","const test = 1234","const test* = 1234"], \"spec_failed": ["if test == 1234:"], \}) call s:add_definition('nim', { \"type": 'function', - \"pcre2_regexp": '(proc|func|macro|template)\s*`?KEYWORD`?\b\s*\(', - \"emacs_regexp": '(proc|func|macro|template)\s*`?JJJ`?\b\s*\(', + \"pcre2_regexp": '(proc|func|macro|template)\s*`?KEYWORD`?\b\*?\s*\(', + \"emacs_regexp": '(proc|func|macro|template)\s*`?JJJ`?\b\*?\s*\(', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["\tproc test(asdf)","proc test()","func test()","macro test()","template test()"], + \"spec_success": ["\tproc test(asdf)","proc test()","func test()","macro test()","template test()","proc test*()"], \"spec_failed": ["\tproc testnot(asdf)","proc testnot()"], \}) call s:add_definition('nim', { \"type": 'type', - \"pcre2_regexp": 'type\s*KEYWORD\b\s*(\{[^}]+\})?\s*=\s*\w+', - \"emacs_regexp": 'type\s*JJJ\b\s*(\{[^}]+\})?\s*=\s*\w+', + \"pcre2_regexp": 'type\s*KEYWORD\b\*?\s*(\{[^}]+\})?\s*=\s*\w+', + \"emacs_regexp": 'type\s*JJJ\b\*?\s*(\{[^}]+\})?\s*=\s*\w+', \"supports": ["ag", "grep", "rg", "git-grep"], - \"spec_success": ["type test = object","type test {.pure.} = enum"], + \"spec_success": ["type test = object","type test {.pure.} = enum","type test* = ref object"], \"spec_failed": ["type testnot = object"], \}) @@ -927,6 +965,42 @@ call s:add_definition('scala', { \"spec_failed": [], \}) +call s:add_definition('solidity', { + \"type": 'function', + \"pcre2_regexp": 'function\s*KEYWORD\s*\(', + \"emacs_regexp": 'function\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["function test() internal","function test (uint x, address y)","function test() external"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'modifier', + \"pcre2_regexp": 'modifier\s*KEYWORD\s*\(', + \"emacs_regexp": 'modifier\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["modifier test()","modifier test ()"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'event', + \"pcre2_regexp": 'event\s*KEYWORD\s*\(', + \"emacs_regexp": 'event\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["event test();","event test (uint indexed x)","event test(uint x, address y)"], + \"spec_failed": [], + \}) + +call s:add_definition('solidity', { + \"type": 'error', + \"pcre2_regexp": 'error\s*KEYWORD\s*\(', + \"emacs_regexp": 'error\s*JJJ\s*\(', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["error test();","error test (uint x)","error test(uint x, address y)"], + \"spec_failed": [], + \}) + call s:add_definition('r', { \"type": 'variable', \"pcre2_regexp": '\bKEYWORD\s*=[^=><]', @@ -963,6 +1037,33 @@ call s:add_definition('perl', { \"spec_failed": [], \}) +call s:add_definition('tcl', { + \"type": 'function', + \"pcre2_regexp": 'proc\s+KEYWORD\s*\{', + \"emacs_regexp": 'proc\s+JJJ\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["proc test{","proc test {"], + \"spec_failed": [], + \}) + +call s:add_definition('tcl', { + \"type": 'variable', + \"pcre2_regexp": 'set\s+KEYWORD', + \"emacs_regexp": 'set\s+JJJ', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["set test 1234"], + \"spec_failed": [], + \}) + +call s:add_definition('tcl', { + \"type": 'variable', + \"pcre2_regexp": '(variable|global)\s+KEYWORD', + \"emacs_regexp": '(variable|global)\s+JJJ', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["variable test","global test"], + \"spec_failed": [], + \}) + call s:add_definition('shell', { \"type": 'function', \"pcre2_regexp": 'function\s*KEYWORD\s*', @@ -1080,6 +1181,33 @@ call s:add_definition('faust', { \"spec_failed": [], \}) +call s:add_definition('fennel', { + \"type": 'variable', + \"pcre2_regexp": '\((local|var)\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\((local|var)\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(local test (foo)","(var test (foo)"], + \"spec_failed": [], + \}) + +call s:add_definition('fennel', { + \"type": 'function', + \"pcre2_regexp": '\(fn\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(fn\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(fn test [foo]"], + \"spec_failed": ["(fn test? [foo]"], + \}) + +call s:add_definition('fennel', { + \"type": 'function', + \"pcre2_regexp": '\(macro\s+KEYWORD($|[^a-zA-Z0-9\?\*-])', + \"emacs_regexp": '\(macro\s+JJJ\j', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["(macro test [foo]"], + \"spec_failed": [], + \}) + call s:add_definition('fortran', { \"type": 'variable', \"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n]+', @@ -1163,8 +1291,8 @@ call s:add_definition('go', { call s:add_definition('javascript', { \"type": 'function', - \"pcre2_regexp": '(service|factory)\(['"]KEYWORD['"]', - \"emacs_regexp": '(service|factory)\(['"]JJJ['"]', + \"pcre2_regexp": '(service|factory)\([''"]KEYWORD[''"]', + \"emacs_regexp": '(service|factory)\([''"]JJJ[''"]', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"], \"spec_failed": [], @@ -1251,10 +1379,28 @@ call s:add_definition('javascript', { \"spec_failed": [], \}) +call s:add_definition('hcl', { + \"type": 'block', + \"pcre2_regexp": '(variable|output|module)\s*"KEYWORD"\s*\{', + \"emacs_regexp": '(variable|output|module)\s*"JJJ"\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["variable \"test\" {","output \"test\" {","module \"test\" {"], + \"spec_failed": [], + \}) + +call s:add_definition('hcl', { + \"type": 'block', + \"pcre2_regexp": '(data|resource)\s*"\w+"\s*"KEYWORD"\s*\{', + \"emacs_regexp": '(data|resource)\s*"\w+"\s*"JJJ"\s*\{', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["data \"openstack_images_image_v2\" \"test\" {","resource \"google_compute_instance\" \"test\" {"], + \"spec_failed": [], + \}) + call s:add_definition('typescript', { \"type": 'function', - \"pcre2_regexp": '(service|factory)\(['"]KEYWORD['"]', - \"emacs_regexp": '(service|factory)\(['"]JJJ['"]', + \"pcre2_regexp": '(service|factory)\([''"]KEYWORD[''"]', + \"emacs_regexp": '(service|factory)\([''"]JJJ[''"]', \"supports": ["ag", "grep", "rg", "git-grep"], \"spec_success": ["module.factory('test', [\"$rootScope\", function($rootScope) {"], \"spec_failed": [], @@ -1399,7 +1545,7 @@ call s:add_definition('haskell', { \"type": 'module', \"pcre2_regexp": '^module\s+KEYWORD\s+', \"emacs_regexp": '^module\s+JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["module Test (exportA, exportB) where"], \"spec_failed": [], \}) @@ -1408,7 +1554,7 @@ call s:add_definition('haskell', { \"type": 'top level function', \"pcre2_regexp": '^\bKEYWORD(?!(\s+::))\s+((.|\s)*?)=\s+', \"emacs_regexp": '^\bJJJ(?!(\s+::))\s+((.|\s)*?)=\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["test n = n * 2","test X{..} (Y a b c) \n bcd \n =\n x * y","test ab cd e@Datatype {..} (Another thing, inTheRow) = \n undefined","test = runRealBasedMode @ext @ctx identity identity","test unwrap wrap nr@Naoeu {..} (Action action, specSpecs) = \n undefined"], \"spec_failed": ["nottest n = n * 2","let testnot x y = x * y","test $ y z","let test a o = mda","test :: Sometype -> AnotherType aoeu kek = undefined"], \}) @@ -1417,7 +1563,7 @@ call s:add_definition('haskell', { \"type": 'type-like', \"pcre2_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+KEYWORD\s+', \"emacs_regexp": '^\s*((data(\s+family)?)|(newtype)|(type(\s+family)?))\s+JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["newtype Test a = Something { b :: Kek }","data Test a b = Somecase a | Othercase b","type family Test (x :: *) (xs :: [*]) :: Nat where","data family Test ","type Test = TestAlias"], \"spec_failed": ["newtype NotTest a = NotTest (Not a)","data TestNot b = Aoeu"], \}) @@ -1426,7 +1572,7 @@ call s:add_definition('haskell', { \"type": '(data)type constructor 1', \"pcre2_regexp": '(data|newtype)\s{1,3}(?!KEYWORD\s+)([^=]{1,40})=((\s{0,3}KEYWORD\s+)|([^=]{0,500}?((?\s*)?KEYWORD\s+', \"emacs_regexp": '^class\s+(.+=>\s*)?JJJ\s+', - \"supports": ["ag", "rg"], + \"supports": ["rg", "ag"], \"spec_success": ["class (Constr1 m, Constr 2) => Test (Kek a) where","class Test (Veryovka a) where "], \"spec_failed": ["class Test2 (Kek a) where","class MakeTest (AoeuTest x y z) where"], \}) @@ -2034,6 +2180,24 @@ call s:add_definition('kotlin', { \"spec_failed": [], \}) +call s:add_definition('zig', { + \"type": 'function', + \"pcre2_regexp": 'fn\s+KEYWORD\b', + \"emacs_regexp": 'fn\s+JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["fn test() void {","fn test(a: i32) i32 {","pub fn test(a: i32) i32 {","export fn test(a: i32) i32 {","extern \"c\" fn test(a: i32) i32 {","inline fn test(a: i32) i32 {"], + \"spec_failed": [], + \}) + +call s:add_definition('zig', { + \"type": 'variable', + \"pcre2_regexp": '(var|const)\s+KEYWORD\b', + \"emacs_regexp": '(var|const)\s+JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["const test: i32 = 3;","var test: i32 = 3;","pub const test: i32 = 3;"], + \"spec_failed": [], + \}) + call s:add_definition('protobuf', { \"type": 'message', \"pcre2_regexp": 'message\s+KEYWORD\s*\{', @@ -2051,3 +2215,30 @@ call s:add_definition('protobuf', { \"spec_success": ["enum test{","enum test {"], \"spec_failed": [], \}) + +call s:add_definition('apex', { + \"type": 'function', + \"pcre2_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}KEYWORD\s*\(', + \"emacs_regexp": '^\s*(?:[\w\[\]]+\s+){1,3}JJJ\s*\(', + \"supports": ["ag", "rg"], + \"spec_success": ["int test()","int test(param)","static int test()","static int test(param)","public static MyType test()","private virtual SomeType test(param)","static int test()","private foo[] test()"], + \"spec_failed": ["test()","testnot()","blah = new test()","foo bar = test()"], + \}) + +call s:add_definition('apex', { + \"type": 'variable', + \"pcre2_regexp": '\s*\bKEYWORD\s*=[^=\n)]+', + \"emacs_regexp": '\s*\bJJJ\s*=[^=\n)]+', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["int test = 1234"], + \"spec_failed": ["if test == 1234:","int nottest = 44"], + \}) + +call s:add_definition('apex', { + \"type": 'type', + \"pcre2_regexp": '(class|interface)\s*KEYWORD\b', + \"emacs_regexp": '(class|interface)\s*JJJ\b', + \"supports": ["ag", "grep", "rg", "git-grep"], + \"spec_success": ["class test:","public class test implements Something"], + \"spec_failed": ["class testnot:","public class testnot implements Something"], + \}) diff --git a/generator/lib/download.rb b/generator/lib/download.rb new file mode 100644 index 0000000..3066edb --- /dev/null +++ b/generator/lib/download.rb @@ -0,0 +1,37 @@ +require 'http' + +class Download + URL = 'https://raw.githubusercontent.com/jacktasia/dumb-jump/master/dumb-jump.el' + PARSE_PATTERNS = { + head: '(defcustom dumb-jump-find-rules', + tail: '"List of regex patttern templates' + } + + def call + result = "" + scp = HTTP.get(URL).to_s + head = scp.index(PARSE_PATTERNS[:head]) + tail = scp.index(PARSE_PATTERNS[:tail]) + + # 1. get body + extracted = scp[head,tail - head] + + # 2. remove definition start + extracted.sub!(PARSE_PATTERNS[:head], '') + + # 3. remove whitespaces and some syntax elements + extracted.strip! + extracted.sub!(/^'\(\(/, '((') + + # 4. remove tabulation + extracted.each_line do |line| + result << if line[0,2] == " " + line[2, line.size - 2] + else + line + end + end + + return result + end +end diff --git a/generator/lib/generate.rb b/generator/lib/generate.rb new file mode 100644 index 0000000..b5bd4d3 --- /dev/null +++ b/generator/lib/generate.rb @@ -0,0 +1,176 @@ +require 'json' +require 'sxp' + +class Generate + LOOKUP_KEYS_TRANSFORM = { + :":type" => :type, + :":supports" => :supports, + :":language" => :language, + :":regex" => :emacs_regexp, + :":tests" => :spec_success, + :":not" => :spec_failed + } + + LOOKUP_KEYS = LOOKUP_KEYS_TRANSFORM.keys + COMMENT_START = :";;" + + LANG_NAMES_CONVERTION_MAP = { + 'c++' => 'cpp' + } + + LANGS_SUPPORTED_ENGINES_OVERRIDES_MAP = { + 'haskell' => ['rg', 'ag'] + } + + def initialize(input_file_path, output_file_path) + throw "file not found #{input_file_path}" unless File.exists?(input_file_path) + + @input = File.read(input_file_path) + @output_file_path = output_file_path + end + + def call + sexps = SXP::Reader::Basic.read(@input) + + unless sexps.is_a?(Array) + raise RuntimeError, "No sexps found" + end + + puts "Total sexps rules to import: #{ sexps.count.to_s }\n\n" + + vimscript = "" + vimscript << definitions_viml() + + sexps.each_with_index do |sexp, i| + result = process_definition(sexp) + next unless result + next if result.empty? + + viml_definition = convert_definition_to_viml(result) + vimscript << viml_definition + end + + outfile = File.new(@output_file_path, 'w') + outfile.print(vimscript) + outfile.close + end + + def process_definition(def_array) + return unless def_array.is_a?(Array) + result = {} + + next_type = nil + + for e in def_array + # comment or key definition + if e == COMMENT_START + next_type = :comment + next + elsif LOOKUP_KEYS.include?(e) + next_type = LOOKUP_KEYS_TRANSFORM[e] + next + end + + # comment body or key value + if next_type == :comment + next + elsif next_type != nil + result[next_type] = e + next_type = nil + next + end + end + + return result + end + + def definitions_viml + r = <<~STR + " NOTES: + " - all language regexps ported from https://github.com/jacktasia/dumb-jump/blob/master/dumb-jump.el + + let s:definitions = {} + + " map any-language to concrete internal s:definitions[language] + let s:filetypes_proxy = { + \\"javascriptreact": "javascript", + \\"c": "cpp", + \\} + + fu! s:add_definition(lang, definition) abort + if !has_key(s:definitions, a:lang) + let s:definitions[a:lang] = [] + endif + + call add(s:definitions[a:lang], a:definition) + endfu + + fu! lang_map#find_definitions(language) abort + if !lang_map#lang_exists(a:language) + return + endif + + return s:definitions[a:language] + endfu + + fu! lang_map#definitions() abort + return s:definitions + endfu + + fu! lang_map#lang_exists(language) abort + return has_key(s:definitions, a:language) + endfu + + fu! lang_map#get_language_from_filetype(ft) abort + if has_key(s:filetypes_proxy, a:ft) + let maybe_lan = s:filetypes_proxy[a:ft] + else + let maybe_lan = a:ft + endif + + if lang_map#lang_exists(maybe_lan) + return maybe_lan + else + return 0 + endif + endfu + STR + + return r + end + + def pcre2_regexp(string) + string = string.dup.to_s + + string.gsub!('JJJ', 'KEYWORD') + string.gsub!('\\j', '($|[^a-zA-Z0-9\\?\\*-])') + + return string + end + + def format_single_quotes(string) + string.gsub("'", "''") + end + + def prepare_supported_engines(language, engines) + override = LANGS_SUPPORTED_ENGINES_OVERRIDES_MAP[language] + (override || engines).to_s + end + + def convert_definition_to_viml(hash = {}) + language = LANG_NAMES_CONVERTION_MAP[hash[:language]] || hash[:language] + + # puts hash[:emacs_regexp].dump + r = "\n" + r << "call s:add_definition('#{language}', {\n" + r << "\t" + '\"type": ' + "'" + hash[:type] + "',\n" + r << "\t" + '\"pcre2_regexp": ' + "'" + format_single_quotes(pcre2_regexp(hash[:emacs_regexp])) + "',\n" + r << "\t" + '\"emacs_regexp": ' + "'" + format_single_quotes(hash[:emacs_regexp].to_s) + "',\n" + r << "\t" + '\"supports": ' + prepare_supported_engines(language, hash[:supports]) + ",\n" + r << "\t" + '\"spec_success": ' + hash[:spec_success].to_a.to_json + ",\n" + r << "\t" + '\"spec_failed": ' + hash[:spec_failed].to_a.to_json + ",\n" + r << "\t" + "\\})\n" + + return r + end +end diff --git a/plugin/any-jump.vim b/plugin/any-jump.vim index 305a512..23e91d9 100644 --- a/plugin/any-jump.vim +++ b/plugin/any-jump.vim @@ -1,16 +1,16 @@ +" TODO_RELEASE: +" - sync file types comments +" - sync file types +" - add custom lang with hot patches (no el files required) - for viml +" - remove emacs regexp for compaction + " TODO: " - wrap for nvim should be configurable -" - fix bg in NeoSolorized theme (add bg set color support) " - [more] button should append N items only on current collection " - add scope :symbol to ruby syntax -" - add lightline integration ? " - add mouse-click evets support " - any-jump-last should also restore cursor position -" - add multiple priview mode -" - ability to toggle help -" - ability to make help hidden by default " - add definitions rules for rails meta expressions in ruby like `has_many :users` -" - better default syntax (which works for some N popular themes) rules " - hl keyword in result line also " - ability to jumps and lookups for library source codes paths " - [hot] display type of definition @@ -19,13 +19,6 @@ " - AnyJumpFirst - if found result from prefered dirs of only one result " then jump to it, othrewise open ui " - [option] auto preview first result -" - is tags cupport really needed? -" i think it cool for perfomance reasons, but sometimes our engine is deeper -" -" TAGS_SUPPORT: -" - use tags definitions engine if prefered -" - what kind of additional data we can provide if tags enabled? (besides -" definitions)A " " UI: " - add rerun search button (first step to refuctoring) (first `R` - rerun @@ -45,9 +38,11 @@ " " TODO_FUTURE_RELEASES: " - [nvim] >> Once a focus to the floating window is lost, the window should disappear. Like many other plugins with floating window. +" add auto-hide option? +" " - AnyJumpPreview " - "save jump" button ?? -" - jumps list ?? +" - jumps list ?? (AnyJumps) " === Vim version check let s:nvim = has('nvim')