psi-jack
/
ultimate-vim
mirror of
1
0
Fork 0
Code Issues Releases Wiki Activity

Add support for Elixir.

This commit is contained in:
Kurtis Moxley 2022-05-19 01:31:41 +08:00
parent 9e29fd54b4
commit d26bc75459
89 changed files with 6799 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sources_non_forked/vim-elixir/.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
profile.log
test_indent.result
doc/tags
.gvim_path

9
sources_non_forked/vim-elixir/.travis.yml Normal file
View File

@ -0,0 +1,9 @@
language: ruby
rvm:
- 2.3.1
before_install: sudo apt-get install vim-gtk
before_script:
- "vim --version"
- "export DISPLAY=:99.0"
- "sh -e /etc/init.d/xvfb start"
script: "grep 'focus:.*true' -R spec/indent spec/syntax && exit -1 || CI=true bin/rspec --color -b -f d"

5
sources_non_forked/vim-elixir/Dockerfile Normal file
View File

@ -0,0 +1,5 @@
FROM ubuntu:latest
RUN apt-get update && apt-get install -yf vim
COPY test.vimrc /root/.vimrc

8
sources_non_forked/vim-elixir/Dockerfile.nvim Normal file
View File

@ -0,0 +1,8 @@
# vi: ft=dockerfile
FROM ubuntu:latest
RUN apt-get update && apt-get install -yf neovim
RUN mkdir -p /root/.config/nvim
COPY test.init.vim /root/.config/nvim/init.vim

7
sources_non_forked/vim-elixir/Gemfile Normal file
View File

@ -0,0 +1,7 @@
source 'https://rubygems.org'
gem 'rspec'
gem 'vimrunner'
gem 'pry'
gem 'diffy'
gem 'parallel_tests'

43
sources_non_forked/vim-elixir/Gemfile.lock Normal file
View File

@ -0,0 +1,43 @@
GEM
remote: https://rubygems.org/
specs:
coderay (1.1.1)
diff-lcs (1.2.5)
diffy (3.2.0)
method_source (0.8.2)
parallel (1.12.1)
parallel_tests (2.21.2)
parallel
pry (0.10.4)
coderay (~> 1.1.0)
method_source (~> 0.8.1)
slop (~> 3.4)
rspec (3.5.0)
rspec-core (~> 3.5.0)
rspec-expectations (~> 3.5.0)
rspec-mocks (~> 3.5.0)
rspec-core (3.5.3)
rspec-support (~> 3.5.0)
rspec-expectations (3.5.0)
diff-lcs (>= 1.2.0, < 2.0)
rspec-support (~> 3.5.0)
rspec-mocks (3.5.0)
diff-lcs (>= 1.2.0, < 2.0)
rspec-support (~> 3.5.0)
rspec-support (3.5.0)
slop (3.6.0)
vimrunner (0.3.3)
PLATFORMS
ruby
x86_64-darwin-19
DEPENDENCIES
diffy
parallel_tests
pry
rspec
vimrunner
BUNDLED WITH
2.2.2

13
sources_non_forked/vim-elixir/ISSUE_TEMPLATE.md Normal file
View File

@ -0,0 +1,13 @@
Filing a bug? Have you already tried updating `vim-elixir`? For indentation/highlighting bugs, please use the following template:
# Actual
```ex
Example code
```
# Expected
```ex
Example code
```

13
sources_non_forked/vim-elixir/LICENSE Normal file
View File

@ -0,0 +1,13 @@
Copyright 2012 Plataformatec
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

143
sources_non_forked/vim-elixir/README.md Normal file
View File

@ -0,0 +1,143 @@
# vim-elixir
[![Build Status](https://travis-ci.org/elixir-editors/vim-elixir.svg?branch=master)](https://travis-ci.org/elixir-editors/vim-elixir)
[Elixir](http://elixir-lang.org) support for vim
## Description
Features:
* Syntax highlighting for Elixir and EEx files
* Filetype detection for `.ex`, `.exs`, `.eex`, `.heex`, `.leex`, and `.sface` files
* Automatic indentation
* Integration between Ecto projects and [vim-dadbod][] for running SQL queries
on defined Ecto repositories
## Installation
`vim-elixir` can be installed either with a plugin manager or by directly copying the files into your vim folders (location varies between platforms)
### Plugin Managers
If you are using a plugin manager then add `vim-elixir` the way you would any other plugin:
```bash
# Using vim 8 native package loading
# http://vimhelp.appspot.com/repeat.txt.html#packages
git clone https://github.com/elixir-editors/vim-elixir.git ~/.vim/pack/my-packages/start/vim-elixir
# Using pathogen
git clone https://github.com/elixir-editors/vim-elixir.git ~/.vim/bundle/vim-elixir
```
```viml
" Using vim-plug
Plug 'elixir-editors/vim-elixir'
" Using Vundle
Plugin 'elixir-editors/vim-elixir'
" Using NeoBundle
NeoBundle 'elixir-editors/vim-elixir'
```
### Manual Installation
If you are not using a package manager then you can use the provided `manual_install.sh` script to copy the files into their respective homes.
Run [./manual_install.sh](manual_install.sh) to copy the contents of each directory in the respective directories inside `~/.vim`.
## Configuration
You must add the following to your `~/.vimrc`:
```
" Enable syntax highlighting
syntax on
" Enables filetype detection, loads ftplugin, and loads indent
" (Not necessary on nvim and may not be necessary on vim 8.2+)
filetype plugin indent on
```
## Notes/Caveats
### `mix format` Integration
We've decided not to include `mix format` integration into `vim-elixir`.
If you'd like to set it up yourself, you have the following options:
* For asynchronous execution of the formatter, have a look at [vim-mix-format](https://github.com/mhinz/vim-mix-format)
* Add it as a `formatprg` (e.g. `setlocal formatprg=mix\ format\ -`)
Why isn't this supported? We've run into two major issues with calling out to `mix format`.
First `mix format` would not work unless your program compiled.
Second `mix format` added an external process dependency to `vim-elixir`.
If someone really wanted to try and add this then we might be able to model it after `vim-go`'s `go fmt` integration
which I think could be acceptable to merge into master.
## Development
### Maintenance Help
`vim-elixir` is looking for new maintainers.
If you get a lot of value from it, know vimscript well, or eager to learn about it then feel free to get in touch with @jbodah (GH issue, elixir-lang Slack)
### Running the Tests
The tests depend on having Ruby installed.
They also depend on a GUI vim (gvim, mvim) with server support.
If you do not have gvim or mvim in your PATH then you can create a `.gvim_path` file in the vim-elixir root directory which specifies the path to the GUI vim executable.
To run the tests: `bundle exec parallel_rspec spec`
### Developing in Docker
You can spawn a container with vim and your development configs using `bin/vim` or `bin/nvim`
### Debugging Indent
```
# Open vim in a container loading this plugin
bin/vim myfile.ex
# Debug statements should be configured to print automatically
# Write/indent some code
:messages
# You should see output like the following:
# ==> Indenting line 3
# text = ' _ -> :wowo'
# testing handler elixir#indent#handle_top_of_file
# testing handler elixir#indent#handle_starts_with_string_continuation
# testing handler elixir#indent#handle_following_trailing_binary_operator
# testing handler elixir#indent#handle_starts_with_pipe
# testing handler elixir#indent#handle_starts_with_binary_operator
# testing handler elixir#indent#handle_inside_block
# pattern matching relative to lnum 2
# current line contains ->; assuming match definition
# line 3: elixir#indent#handle_inside_block returned 4
# 1 change; before #1 4 seconds ago
#
# This tells you which line is being inspected as well as which handlers are being run
# and which branches are being exercised by those handlers
```
### Feature Wishlist
Here is a list of features that I think would be great additions to `vim-elixir`:
* Regularly merging `vim-elixir` into `vim` and keeping the sync up-to-date
* Fixing our build so it can run regularly on CI
* Live view support
* Testing .exs files and ensuring feature compatibility between .ex and .exs
* Documentation (e.g. `:h vim-elixir`)
* README docs for various .vimrc options/flags
* Identifying and rewriting tests that conflict with `mix format`
* Fixes for indentation rule edge cases (e.g. `with`, see GH issues for examples)
* Simplifying syntax rules
* Performance optimizations for syntax/indent rules (especially for determining if something is a string)
[vim-dadbod]: https://github.com/tpope/vim-dadbod

20
sources_non_forked/vim-elixir/autoload/db/adapter/ecto.vim Normal file
View File

@ -0,0 +1,20 @@
let s:path = expand('<sfile>:h')
let s:cmd = join(['mix', 'run', '--no-start', '--no-compile', shellescape(s:path.'/get_repos.exs')])
function! s:repo_list() abort
return map(systemlist(s:cmd), 'split(v:val)')
endfunction
function! db#adapter#ecto#canonicalize(url) abort
for l:item in s:repo_list()
let l:name = get(l:item, 0)
let l:url = get(l:item, 1)
if !empty(l:name) && 'ecto:'.l:name ==# a:url
return l:url
endif
endfor
endfunction
function! db#adapter#ecto#complete_opaque(url) abort
return map(s:repo_list(), 'v:val[0]')
endfunction

66
sources_non_forked/vim-elixir/autoload/db/adapter/get_repos.exs Normal file
View File

@ -0,0 +1,66 @@
defmodule LoadRepos do
defp load_apps do
:code.get_path()
|> Enum.flat_map(fn app_dir ->
Path.join(app_dir, "*.app") |> Path.wildcard()
end)
|> Enum.map(fn app_file ->
app_file |> Path.basename() |> Path.rootname(".app") |> String.to_atom()
end)
|> Enum.map(&Application.load/1)
end
defp configs do
for {app, _, _} <- Application.loaded_applications(),
repos = Application.get_env(app, :ecto_repos),
is_list(repos) and repos != [],
repo <- repos,
do: {repo, Map.new(repo.config())}
end
defp config_to_url(_, %{url: url}), do: url
defp config_to_url(repo, config) do
host =
case Map.fetch(config, :socket_dir) do
:error -> Map.fetch!(config, :hostname)
{:ok, socket_dir} -> socket_dir
end
username = Map.get(config, :username)
password = Map.get(config, :password)
database = Map.get(config, :database)
parameters = Map.get(config, :parameters, [])
%URI{
scheme: adapter_to_string(repo.__adapter__),
host: "",
path: Path.join("/", database),
query: encode_options([host: host, user: username, password: password] ++ parameters)
}
|> URI.to_string()
end
defp adapter_to_string(Ecto.Adapters.Postgres), do: "postgres"
defp adapter_to_string(Ecto.Adapters.MySQL), do: "mysql"
defp adapter_to_string(mod), do: raise("Unknown adapter #{inspect(mod)}")
defp encode_options(opts) do
cleaned =
for {k, v} <- opts, not is_nil(v), do: {k, v}
URI.encode_query(cleaned)
end
def main do
load_apps()
configs()
|> Enum.map(fn {repo, config} ->
[inspect(repo), ?\s, config_to_url(repo, config)]
end)
|> Enum.intersperse(?\n)
|> IO.puts()
end
end
LoadRepos.main()

481
sources_non_forked/vim-elixir/autoload/elixir/indent.vim Normal file
View File

@ -0,0 +1,481 @@
if !exists("g:elixir_indent_max_lookbehind")
let g:elixir_indent_max_lookbehind = 30
endif
" Return the effective value of 'shiftwidth'
function! s:sw()
return &shiftwidth == 0 ? &tabstop : &shiftwidth
endfunction
function! elixir#indent#indent(lnum)
let lnum = a:lnum
let text = getline(lnum)
let prev_nb_lnum = prevnonblank(lnum-1)
let prev_nb_text = getline(prev_nb_lnum)
call s:debug("==> Indenting line " . lnum)
call s:debug("text = '" . text . "'")
let [_, curs_lnum, curs_col, _] = getpos('.')
call cursor(lnum, 0)
let handlers = [
\'inside_embedded_view',
\'top_of_file',
\'starts_with_string_continuation',
\'following_trailing_binary_operator',
\'starts_with_pipe',
\'starts_with_binary_operator',
\'inside_block',
\'starts_with_end',
\'inside_generic_block',
\'follow_prev_nb'
\]
for handler in handlers
call s:debug('testing handler elixir#indent#handle_'.handler)
let context = {'lnum': lnum, 'text': text, 'first_nb_char_idx': match(text, '\w'), 'prev_nb_lnum': prev_nb_lnum, 'prev_nb_text': prev_nb_text}
let indent = function('elixir#indent#handle_'.handler)(context)
if indent == -2
" Keep indent the same
call s:debug('line '.lnum.': elixir#indent#handle_'.handler.' returned -2; returning indent of -1')
call cursor(curs_lnum, curs_col)
return -1
elseif indent != -1
call s:debug('line '.lnum.': elixir#indent#handle_'.handler.' returned '.indent)
call cursor(curs_lnum, curs_col)
return indent
endif
endfor
call s:debug("defaulting")
call cursor(curs_lnum, curs_col)
return 0
endfunction
function! s:debug(str)
if exists("g:elixir_indent_debug") && g:elixir_indent_debug
echom a:str
endif
endfunction
function! s:starts_with(context, expr)
return s:_starts_with(a:context.text, a:expr, a:context.lnum)
endfunction
function! s:prev_starts_with(context, expr)
return s:_starts_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
endfunction
function! s:in_embedded_view()
let groups = map(synstack(line('.'), col('.')), "synIDattr(v:val, 'name')")
for group in ['elixirPhoenixESigil', 'elixirLiveViewSigil', 'elixirSurfaceSigil']
if index(groups, group) >= 0
return 1
endif
endfor
return 0
endfunction
" Returns 0 or 1 based on whether or not the text starts with the given
" expression and is not a string or comment
function! s:_starts_with(text, expr, lnum)
let pos = match(a:text, '^\s*'.a:expr)
if pos == -1
return 0
else
" NOTE: @jbodah 2017-02-24: pos is the index of the match which is
" zero-indexed. Add one to make it the column number
if s:is_string_or_comment(a:lnum, pos + 1)
return 0
else
return 1
end
end
endfunction
function! s:prev_ends_with(context, expr)
return s:_ends_with(a:context.prev_nb_text, a:expr, a:context.prev_nb_lnum)
endfunction
" Returns 0 or 1 based on whether or not the text ends with the given
" expression and is not a string or comment
function! s:_ends_with(text, expr, lnum)
let pos = match(a:text, a:expr.'\s*$')
if pos == -1
return 0
else
if s:is_string_or_comment(a:lnum, pos)
return 0
else
return 1
end
end
endfunction
" Returns 0 or 1 based on whether or not the given line number and column
" number pair is a string or comment
function! s:is_string_or_comment(line, col)
return s:syntax_name(a:line, a:col) =~ '\%(String\|Comment\|CharList\)'
endfunction
function! s:syntax_name(line, col)
return synIDattr(synID(a:line, a:col, 1), "name")
endfunction
" Skip expression for searchpair. Returns 0 or 1 based on whether the value
" under the cursor is a string or comment
function! elixir#indent#searchpair_back_skip()
" NOTE: @jbodah 2017-02-27: for some reason this function gets called with
" and index that doesn't exist in the line sometimes. Detect and account for
" that situation
let curr_col = col('.')
if getline('.')[curr_col-1] == ''
let curr_col = curr_col-1
endif
return s:is_string_or_comment(line('.'), curr_col)
endfunction
" DRY up regex for keywords that 1) makes sure we only look at complete words
" and 2) ignores atoms
function! s:keyword(expr)
return ':\@<!\<\C\%('.a:expr.'\)\>:\@!'
endfunction
" Start at the end of text and search backwards looking for a match. Also peek
" ahead if we get a match to make sure we get a complete match. This means
" that the result should be the position of the start of the right-most match
function! s:find_last_pos(lnum, text, match)
let last = len(a:text) - 1
let c = last
while c >= 0
let substr = strpart(a:text, c, last)
let peek = strpart(a:text, c - 1, last)
let ss_match = match(substr, a:match)
if ss_match != -1
let peek_match = match(peek, a:match)
if peek_match == ss_match + 1
let syng = synIDattr(synID(a:lnum, c + ss_match, 1), 'name')
if syng !~ '\%(String\|Comment\|CharList\)'
return c + ss_match
end
end
end
let c -= 1
endwhile
return -1
endfunction
function! elixir#indent#handle_inside_embedded_view(context)
if !s:in_embedded_view()
return -1
endif
" Multi-line Surface data delimiters
let pair_lnum = searchpair('{{', '', '}}', 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
if pair_lnum
if a:context.text =~ '}}$'
return indent(pair_lnum)
elseif a:context.text =~ '}}*>$'
return -1
elseif s:prev_ends_with(a:context, '[\|%{')
return indent(a:context.prev_nb_lnum) + s:sw()
elseif a:context.prev_nb_text =~ ',$'
return indent(a:context.prev_nb_lnum)
else
return indent(pair_lnum) + s:sw()
endif
endif
" Multi-line opening tag -- >, />, or %> are on a different line that their opening <
let pair_lnum = searchpair('^\s\+<.*[^>]$', '', '^[^<]*[/%}]\?>$', 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
if pair_lnum
if a:context.text =~ '^\s\+\%\(>\|\/>\|%>\|}}>\)$'
call s:debug("current line is a lone >, />, or %>")
return indent(pair_lnum)
elseif a:context.text =~ '\%\(>\|\/>\|%>\|}}>\)$'
call s:debug("current line ends in >, />, or %>")
if s:prev_ends_with(a:context, ',')
return indent(a:context.prev_nb_lnum)
else
return -1
endif
else
call s:debug("in the body of a multi-line opening tag")
return indent(pair_lnum) + s:sw()
endif
endif
" Special cases
if s:prev_ends_with(a:context, '^[^<]*do\s%>')
call s:debug("prev line closes a multi-line do block")
return indent(a:context.prev_nb_lnum)
elseif a:context.prev_nb_text =~ 'do\s*%>$'
call s:debug("prev line opens a do block")
return indent(a:context.prev_nb_lnum) + s:sw()
elseif a:context.text =~ '^\s\+<\/[a-zA-Z0-9\.\-_]\+>\|<% end %>'
call s:debug("a single closing tag")
if a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>.*<\/[a-zA-Z0-9\.\-_]\+>$'
call s:debug("opening and closing tags are on the same line")
return indent(a:context.prev_nb_lnum) - s:sw()
elseif a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>\|\s\+>'
call s:debug("prev line is opening html tag or single >")
return indent(a:context.prev_nb_lnum)
elseif s:prev_ends_with(a:context, '^[^<]*\%\(do\s\)\@<!%>')
call s:debug("prev line closes a multi-line eex tag")
return indent(a:context.prev_nb_lnum) - 2 * s:sw()
else
return indent(a:context.prev_nb_lnum) - s:sw()
endif
elseif a:context.text =~ '^\s*<%\s*\%(end\|else\|catch\|rescue\)\>.*%>'
call s:debug("eex middle or closing eex tag")
return indent(a:context.prev_nb_lnum) - s:sw()
elseif a:context.prev_nb_text =~ '\s*<\/\|<% end %>$'
call s:debug("prev is closing tag")
return indent(a:context.prev_nb_lnum)
elseif a:context.prev_nb_text =~ '^\s\+<[^%\/]*[^/]>.*<\/[a-zA-Z0-9\.\-_]\+>$'
call s:debug("opening and closing tags are on the same line")
return indent(a:context.prev_nb_lnum)
elseif s:prev_ends_with(a:context, '\s\+\/>')
call s:debug("prev ends with a single \>")
return indent(a:context.prev_nb_lnum)
elseif s:prev_ends_with(a:context, '^[^<]*\/>')
call s:debug("prev line is closing a multi-line self-closing tag")
return indent(a:context.prev_nb_lnum) - s:sw()
elseif s:prev_ends_with(a:context, '^\s\+<.*\/>')
call s:debug("prev line is closing self-closing tag")
return indent(a:context.prev_nb_lnum)
elseif a:context.prev_nb_text =~ '^\s\+%\?>$'
call s:debug("prev line is a single > or %>")
return indent(a:context.prev_nb_lnum) + s:sw()
endif
" Simple HTML (ie, opening tag is not split across lines)
let pair_lnum = searchpair('^\s\+<[^%\/].*[^\/>]>$', '', '^\s\+<\/\w\+>$', 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
if pair_lnum
call s:debug("simple HTML")
if a:context.text =~ '^\s\+<\/\w\+>$'
return indent(pair_lnum)
else
return indent(pair_lnum) + s:sw()
endif
endif
return -1
endfunction
function! elixir#indent#handle_top_of_file(context)
if a:context.prev_nb_lnum == 0
return 0
else
return -1
end
endfunction
function! elixir#indent#handle_starts_with_string_continuation(context)
if s:syntax_name(a:context.lnum, a:context.first_nb_char_idx) =~ '\(String\|Comment\|CharList\)$'
return -2
else
return -1
end
endfunction
function! elixir#indent#handle_follow_prev_nb(context)
return s:get_base_indent(a:context.prev_nb_lnum, a:context.prev_nb_text)
endfunction
" Given the line at `lnum`, returns the indent of the line that acts as the 'base indent'
" for this line. In particular it traverses backwards up things like pipelines
" to find the beginning of the expression
function! s:get_base_indent(lnum, text)
let prev_nb_lnum = prevnonblank(a:lnum - 1)
let prev_nb_text = getline(prev_nb_lnum)
let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
let data_structure_close = '\%(\]\|}\|)\)'
let pipe = '|>'
if s:_starts_with(a:text, binary_operator, a:lnum)
return s:get_base_indent(prev_nb_lnum, prev_nb_text)
elseif s:_starts_with(a:text, pipe, a:lnum)
return s:get_base_indent(prev_nb_lnum, prev_nb_text)
elseif s:_ends_with(prev_nb_text, binary_operator, prev_nb_lnum)
return s:get_base_indent(prev_nb_lnum, prev_nb_text)
elseif s:_ends_with(a:text, data_structure_close, a:lnum)
let data_structure_open = '\%(\[\|{\|(\)'
let close_match_idx = match(a:text, data_structure_close . '\s*$')
call cursor(a:lnum, close_match_idx + 1)
let [open_match_lnum, open_match_col] = searchpairpos(data_structure_open, '', data_structure_close, 'bnW')
let open_match_text = getline(open_match_lnum)
return s:get_base_indent(open_match_lnum, open_match_text)
else
return indent(a:lnum)
endif
endfunction
function! elixir#indent#handle_following_trailing_binary_operator(context)
let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
if s:prev_ends_with(a:context, binary_operator)
return indent(a:context.prev_nb_lnum) + s:sw()
else
return -1
endif
endfunction
function! elixir#indent#handle_starts_with_pipe(context)
if s:starts_with(a:context, '|>')
let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
if pos == -1
return indent(a:context.prev_nb_lnum)
else
let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
if next_word_pos == -1
return indent(a:context.prev_nb_lnum) + s:sw()
else
return pos + 1 + next_word_pos
end
end
else
return -1
endif
endfunction
function! elixir#indent#handle_starts_with_end(context)
if s:starts_with(a:context, s:keyword('end'))
let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end').'\zs', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
return indent(pair_lnum)
else
return -1
endif
endfunction
function! elixir#indent#handle_starts_with_binary_operator(context)
let binary_operator = '\%(=\|<>\|>>>\|<=\|||\|+\|\~\~\~\|-\|&&\|<<<\|/\|\^\^\^\|\*\)'
if s:starts_with(a:context, binary_operator)
let match_operator = '\%(!\|=\|<\|>\)\@<!=\%(=\|>\|\~\)\@!'
let pos = s:find_last_pos(a:context.prev_nb_lnum, a:context.prev_nb_text, match_operator)
if pos == -1
return indent(a:context.prev_nb_lnum)
else
let next_word_pos = match(strpart(a:context.prev_nb_text, pos+1, len(a:context.prev_nb_text)-1), '\S')
if next_word_pos == -1
return indent(a:context.prev_nb_lnum) + s:sw()
else
return pos + 1 + next_word_pos
end
end
else
return -1
endif
endfunction
" To handle nested structures properly we need to find the innermost
" nested structure. For example, we might be in a function in a map in a
" function, etc... so we need to first figure out what the innermost structure
" is then forward execution to the proper handler
function! elixir#indent#handle_inside_block(context)
let start_pattern = '\C\%(\<with\>\|\<if\>\|\<case\>\|\<cond\>\|\<try\>\|\<receive\>\|\<fn\>\|{\|\[\|(\)'
let end_pattern = '\C\%(\<end\>\|\]\|}\|)\)'
" hack - handle do: better
let block_info = searchpairpos(start_pattern, '', end_pattern, 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip() || getline(line('.')) =~ 'do:'", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
let block_start_lnum = block_info[0]
call s:debug("block_start_lnum=" . block_start_lnum)
let block_start_col = block_info[1]
if block_start_lnum != 0 || block_start_col != 0
let block_text = getline(block_start_lnum)
let block_start_char = block_text[block_start_col - 1]
call s:debug("block_start_char=" . block_start_char)
let never_match = ''
let config = {
\'f': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
\'c': {'aligned_clauses': s:keyword('end'), 'pattern_match_clauses': never_match},
\'t': {'aligned_clauses': s:keyword('end\|catch\|rescue\|after\|else'), 'pattern_match_clauses': s:keyword('catch\|rescue\|else')},
\'r': {'aligned_clauses': s:keyword('end\|after'), 'pattern_match_clauses': s:keyword('after')},
\'i': {'aligned_clauses': s:keyword('end\|else'), 'pattern_match_clauses': never_match},
\'[': {'aligned_clauses': ']', 'pattern_match_clauses': never_match},
\'{': {'aligned_clauses': '}', 'pattern_match_clauses': never_match},
\'(': {'aligned_clauses': ')', 'pattern_match_clauses': never_match}
\}
" if `with` clause...
if block_start_char == 'w'
call s:debug("testing s:handle_with")
return s:handle_with(block_start_lnum, block_start_col, a:context)
else
let block_config = config[block_start_char]
" if aligned clause (closing tag/`else` clause/etc...) then indent this
" at the same level as the block open tag (e.g. `if`/`case`/etc...)
if s:starts_with(a:context, block_config.aligned_clauses)
call s:debug("clause")
return indent(block_start_lnum)
else
if block_config.pattern_match_clauses == never_match
let relative_lnum = block_start_lnum
else
let clause_lnum = searchpair(block_config.pattern_match_clauses, '', '*', 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()", block_start_lnum)
call s:debug("clause_lum=" . clause_lnum)
let relative_lnum = max([clause_lnum, block_start_lnum])
end
call s:debug("pattern matching relative to lnum " . relative_lnum)
return s:do_handle_pattern_match_block(relative_lnum, a:context)
endif
end
else
return -1
end
endfunction
function! s:handle_with(start_lnum, start_col, context)
let block_info = searchpairpos('\C\%(\<with\>\|\<do\>\|\<else\>\)', '', s:keyword('end'), 'bnW', "line('.') == " . line('.') . " || elixir#indent#searchpair_back_skip()")
let block_start_lnum = block_info[0]
let block_start_col = block_info[1]
let block_start_text = getline(block_start_lnum)
let block_start_char = block_start_text[block_start_col - 1]
if s:starts_with(a:context, s:keyword('do\|else\|end'))
return indent(a:start_lnum)
elseif block_start_char == 'w' || s:starts_with(a:context, '\C\(do\|else\):')
return indent(a:start_lnum) + 5
elseif s:_starts_with(block_start_text, '\C\(do\|else\):', a:start_lnum)
return indent(block_start_lnum) + s:sw()
else
return s:do_handle_pattern_match_block(a:start_lnum, a:context)
end
endfunction
function! s:do_handle_pattern_match_block(relative_line, context)
let relative_indent = indent(a:relative_line)
" hack!
if a:context.text =~ '\(fn.*\)\@<!->'
call s:debug("current line contains ->; assuming match definition")
return relative_indent + s:sw()
elseif search('\(fn.*\)\@<!->', 'bnW', a:relative_line) != 0
call s:debug("a previous line contains ->; assuming match handler")
return relative_indent + 2 * s:sw()
else
call s:debug("couldn't find any previous ->; assuming body text")
return relative_indent + s:sw()
end
endfunction
function! elixir#indent#handle_inside_generic_block(context)
let pair_lnum = searchpair(s:keyword('do\|fn'), '', s:keyword('end'), 'bW', "line('.') == ".a:context.lnum." || s:is_string_or_comment(line('.'), col('.'))", max([0, a:context.lnum - g:elixir_indent_max_lookbehind]))
if pair_lnum
" TODO: @jbodah 2017-03-29: this should probably be the case in *all*
" blocks
if s:prev_ends_with(a:context, ',')
return indent(pair_lnum) + 2 * s:sw()
else
return indent(pair_lnum) + s:sw()
endif
else
return -1
endif
endfunction

24
sources_non_forked/vim-elixir/autoload/elixir/util.vim Normal file
View File

@ -0,0 +1,24 @@
function! elixir#util#get_filename(word) abort
let word = a:word
" get first thing that starts uppercase, until the first space or end of line
let word = substitute(word,'^\s*\(\u[^ ]\+\).*$','\1','g')
" remove any trailing characters that don't look like a nested module
let word = substitute(word,'\.\U.*$','','g')
" replace module dots with slash
let word = substitute(word,'\.','/','g')
" remove any special chars
let word = substitute(word,'[^A-z0-9-_/]','','g')
" convert to snake_case
let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
let word = substitute(word,'\(\u\+\)\(\u\l\)','\1_\2','g')
let word = substitute(word,'\(\l\|\d\)\(\u\)','\1_\2','g')
let word = substitute(word,'-','_','g')
let word = tolower(word)
return word
endfunction

3
sources_non_forked/vim-elixir/bin/nvim Executable file
View File

@ -0,0 +1,3 @@
#! /usr/bin/env sh
docker-compose build
docker-compose run nvim nvim $1

25
sources_non_forked/vim-elixir/bin/profile Executable file
View File

@ -0,0 +1,25 @@
#! /usr/bin/env ruby
require 'bundler/setup'
require 'vimrunner'
dir = File.expand_path('..', __dir__)
plugin = 'ftdetect/elixir.vim'
vim = Vimrunner.start_gvim
vim.add_plugin(dir, plugin)
vim.normal ':let g:elixir_indent_debug=0<CR>'
vim.edit! 'large_file.ex'
# remove all indentation
vim.normal 'ggVG999<<'
vim.normal ':profile start profile.log<CR>'
vim.normal ':profile func *<CR>'
vim.normal ':profile file *<CR>'
t1 = Time.now
# force vim to indent the file
vim.normal 'gg=G'
vim.normal ':profile pause<CR>'
vim.normal ':q!<CR>'
Process.wait vim.server.pid
t2 = Time.now
puts "Took #{t2-t1} seconds to indent large_file.ex. Profile logged to profile.log"

8
sources_non_forked/vim-elixir/bin/projects_to_test.txt Normal file
View File

@ -0,0 +1,8 @@
wistia/ttl_cache
wistia/generational_cache
wistia/gen_poller
wistia/assignment_ex
wistia/http_monitor
wistia/impersonate_ex
wistia/m3u8_parser
wistia/simple_http_server

17
sources_non_forked/vim-elixir/bin/rspec Executable file
View File

@ -0,0 +1,17 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
#
# This file was generated by Bundler.
#
# The application 'rspec' is installed as part of a gem, and
# this file is here to facilitate running it.
#
require "pathname"
ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
Pathname.new(__FILE__).realpath)
require "rubygems"
require "bundler/setup"
load Gem.bin_path("rspec-core", "rspec")

3
sources_non_forked/vim-elixir/bin/test_directory Executable file
View File

@ -0,0 +1,3 @@
#! /usr/bin/env sh
dirs=`find $1 -iname '*.ex' -o -iname '*.exs' | grep -v '/deps/'`
bin/test_indent $dirs

3
sources_non_forked/vim-elixir/bin/test_for_regressions Executable file
View File

@ -0,0 +1,3 @@
#! /usr/bin/env sh
rm -rf tmp
cat bin/projects_to_test.txt | xargs -n 1 -I{} sh -c 'git clone -q git@github.com:{}.git tmp && echo "Testing directory: {}..." && bin/test_directory tmp && rm -rf tmp'

57
sources_non_forked/vim-elixir/bin/test_indent Executable file
View File

@ -0,0 +1,57 @@
#! /usr/bin/env ruby
require 'bundler/setup'
require 'vimrunner'
require 'diffy'
require 'fileutils'
dir = File.expand_path('..', __dir__)
plugin = 'ftdetect/elixir.vim'
def bm
t1 = Time.now
yield
Time.now - t1
end
def detect_change(f)
pre = File.read(f)
pre = strip_doc_blocks(pre)
yield
post = File.read('test_indent.result')
post = strip_doc_blocks(post)
pre == post ? nil : Diffy::Diff.new(pre, post)
end
def strip_doc_blocks(body)
body.gsub(/@\w+ """.*"""/m, '')
end
ARGV.each do |f|
vim = Vimrunner.start_gvim
vim.add_plugin(dir, plugin)
vim.edit! f
print "## Testing #{File.expand_path(f)} ... "
time = nil
diff = detect_change(f) do
time = bm do
vim.normal 'ggVG999<<'
vim.normal 'gg=G'
vim.normal ':w! test_indent.result<CR>'
vim.normal ':q!<CR>'
Process.wait vim.server.pid
end
end
if diff
puts "error [#{time}s]"
puts diff
else
puts "ok [#{time}s]"
end
end
FileUtils.rm 'test_indent.result'

3
sources_non_forked/vim-elixir/bin/vim Executable file
View File

@ -0,0 +1,3 @@
#! /usr/bin/env sh
docker-compose build
docker-compose run vim

11
sources_non_forked/vim-elixir/compiler/credo.vim Normal file
View File

@ -0,0 +1,11 @@
if exists('current_compiler')
finish
endif
let current_compiler = 'credo'
if exists(":CompilerSet") != 2
command -nargs=* CompilerSet setlocal <args>
endif
CompilerSet errorformat=%f:%l:%c:\ %t:\ %m,%f:%l:\ %t:\ %m
CompilerSet makeprg=mix\ credo\ suggest\ --format=flycheck

25
sources_non_forked/vim-elixir/compiler/exunit.vim Normal file
View File

@ -0,0 +1,25 @@
if exists("current_compiler")
finish
endif
let current_compiler = "exunit"
if exists(":CompilerSet") != 2 " older Vim always used :setlocal
command -nargs=* CompilerSet setlocal <args>
endif
let s:cpo_save = &cpo
set cpo-=C
CompilerSet makeprg=mix\ test
CompilerSet errorformat=
\%E\ \ %n)\ %m,
\%+G\ \ \ \ \ **\ %m,
\%+G\ \ \ \ \ stacktrace:,
\%C\ \ \ \ \ %f:%l,
\%+G\ \ \ \ \ \ \ (%\\w%\\+)\ %f:%l:\ %m,
\%+G\ \ \ \ \ \ \ %f:%l:\ %.%#,
\**\ (%\\w%\\+)\ %f:%l:\ %m
let &cpo = s:cpo_save
unlet s:cpo_save
" vim: nowrap sw=2 sts=2 ts=8:

16
sources_non_forked/vim-elixir/compiler/mix.vim Normal file
View File

@ -0,0 +1,16 @@
if exists('current_compiler')
finish
endif
let current_compiler = 'mix'
if exists(":CompilerSet") != 2
command -nargs=* CompilerSet setlocal <args>
endif
CompilerSet makeprg=mix\ compile
CompilerSet errorformat=
\%Wwarning:\ %m,
\%C%f:%l,%Z,
\%E==\ Compilation\ error\ in\ file\ %f\ ==,
\%C**\ (%\\w%\\+)\ %f:%l:\ %m,%Z

112
sources_non_forked/vim-elixir/doc/elixir.txt Normal file
View File

@ -0,0 +1,112 @@
*elixir.txt* Vim configuration files for Elixir http://elixir-lang.org/
Author: Plataformatec
License: Apache License Version 2.0
==============================================================================
CONTENTS *elixir-contents*
INTRODUCTION |elixir-introduction|
INTERFACE |elixir-interface|
FUNCTIONS |elixir-functions|
KEY MAPPINGS |elixir-key-mappings|
OPTIONS |elixir-options|
SETTINGS |elixir-settings|
==============================================================================
INTRODUCTION *elixir-introduction*
*elixir* provides Vim configuration files for Elixir http://elixir-lang.org/
* Syntax highlighting for Elixir and EEx files
* Filetype detection for `.ex`, `.exs`, `.eex`, `.heex`, `.leex`, and `.sface` files
* Automatic indentation
* Integration between Ecto projects and |vim-dadbod| for running SQL queries
on defined Ecto repositories
Latest Version:
https://github.com/elixir-editors/vim-elixir
==============================================================================
INTERFACE *elixir-interface*
------------------------------------------------------------------------------
FUNCTIONS *elixir-functions*
db#adapter#ecto#canonicalize({url}) *db#adapter#ecto#canonicalize()*
TODO
db#adapter#ecto#complete_opaque({url}) *db#adapter#ecto#complete_opaque()*
TODO
elixir#indent#indent({lnum}) *elixir#indent#indent()*
TODO
elixir#indent#searchpair_back_skip() *elixir#indent#searchpair_back_skip()*
TODO
*elixir#indent#handle_top_of_file()*
elixir#indent#handle_top_of_file({context})
TODO
*elixir#indent#handle_follow_prev_nb()*
elixir#indent#handle_follow_prev_nb({context})
TODO
*elixir#indent#handle_following_trailing_binary_operator()*
elixir#indent#handle_following_trailing_binary_operator({context})
TODO
*elixir#indent#handle_starts_with_pipe()*
elixir#indent#handle_starts_with_pipe({context})
TODO
*elixir#indent#handle_starts_with_end()*
elixir#indent#handle_starts_with_end({context})
TODO
*elixir#indent#handle_starts_with_binary_operator()*
elixir#indent#handle_starts_with_binary_operator({context})
TODO
*elixir#indent#handle_inside_block()*
elixir#indent#handle_inside_block({context})
TODO
*elixir#indent#handle_inside_generic_block()*
elixir#indent#handle_inside_generic_block({context})
TODO
elixir#util#get_filename({word}) *elixir#util#get_filename({word})*
TODO
------------------------------------------------------------------------------
KEY MAPPINGS *elixir-key-mappings*
TODO
==============================================================================
SETTINGS *elixir-settings*
*g:eelixir_default_subtype*
TODO
*g:elixir_indent_debug*
TODO
*g:elixir_indent_max_lookbehind*
TODO
*g:elixir_use_markdown_for_docs*
TODO
*g:path*
TODO
==============================================================================
vim:tw=78:fo=tcq2mM:ts=8:ft=help:norl

16
sources_non_forked/vim-elixir/docker-compose.yml Normal file
View File

@ -0,0 +1,16 @@
version: "2"
services:
vim:
build:
context: .
dockerfile: Dockerfile
volumes:
- .:/root/vim-elixir
working_dir: /root/vim-elixir
nvim:
build:
context: .
dockerfile: Dockerfile.nvim
volumes:
- .:/root/vim-elixir
working_dir: /root/vim-elixir

8
sources_non_forked/vim-elixir/ftdetect/elixir.vim Normal file
View File

@ -0,0 +1,8 @@
au BufRead,BufNewFile *.lexs set filetype=elixir "File extension used by https://github.com/mhanberg/temple
au BufRead,BufNewFile * call s:DetectElixir()
function! s:DetectElixir()
if (!did_filetype() || &filetype !=# 'elixir') && getline(1) =~# '^#!.*\<elixir\>'
set filetype=elixir
endif
endfunction

117
sources_non_forked/vim-elixir/ftplugin/eelixir.vim Normal file
View File

@ -0,0 +1,117 @@
if exists("b:did_ftplugin")
finish
endif
let s:save_cpo = &cpo
set cpo-=C
let s:undo_ftplugin = ""
let s:browsefilter = "All Files (*.*)\t*.*\n"
let s:match_words = ""
if !exists("g:eelixir_default_subtype")
let g:eelixir_default_subtype = "html"
endif
if !exists("b:eelixir_subtype")
let s:lines = join(getline(1, 5) + [getline('$')], "\n")
let b:eelixir_subtype = matchstr(s:lines,'eelixir_subtype=\zs\w\+')
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^eex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^heex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^leex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^sface\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(substitute(expand("%:t"),'\c\%(\.eex\|\.heex\|\.leex\|\.sface\|\.eelixir\)\+$','',''),'\.\zs\w\+$')
endif
if b:eelixir_subtype == 'ex'
let b:eelixir_subtype = 'elixir'
elseif b:eelixir_subtype == 'exs'
let b:eelixir_subtype = 'elixir'
elseif b:eelixir_subtype == 'yml'
let b:eelixir_subtype = 'yaml'
elseif b:eelixir_subtype == 'js'
let b:eelixir_subtype = 'javascript'
elseif b:eelixir_subtype == 'txt'
" Conventional; not a real file type
let b:eelixir_subtype = 'text'
elseif b:eelixir_subtype == ''
let b:eelixir_subtype = g:eelixir_default_subtype
endif
endif
if exists("b:eelixir_subtype") && b:eelixir_subtype != ''
exe "runtime! ftplugin/".b:eelixir_subtype.".vim ftplugin/".b:eelixir_subtype."_*.vim ftplugin/".b:eelixir_subtype."/*.vim"
else
runtime! ftplugin/html.vim ftplugin/html_*.vim ftplugin/html/*.vim
endif
unlet! b:did_ftplugin
" Override our defaults if these were set by an included ftplugin.
if exists("b:undo_ftplugin")
let s:undo_ftplugin = b:undo_ftplugin
unlet b:undo_ftplugin
endif
if exists("b:browsefilter")
let s:browsefilter = b:browsefilter
unlet b:browsefilter
endif
if exists("b:match_words")
let s:match_words = b:match_words
unlet b:match_words
endif
runtime! ftplugin/elixir.vim ftplugin/elixir_*.vim ftplugin/elixir/*.vim
let b:did_ftplugin = 1
" Combine the new set of values with those previously included.
if exists("b:undo_ftplugin")
let s:undo_ftplugin = b:undo_ftplugin . " | " . s:undo_ftplugin
endif
if exists ("b:browsefilter")
let s:browsefilter = substitute(b:browsefilter,'\cAll Files (\*\.\*)\t\*\.\*\n','','') . s:browsefilter
endif
if exists("b:match_words")
let s:match_words = b:match_words . ',' . s:match_words
endif
" Load the combined list of match_words for matchit.vim
if exists("loaded_matchit")
let b:match_words = s:match_words
endif
if !exists('b:surround_45')
" When using surround `-` (ASCII 45) would provide `<% selection %>`
let b:surround_45 = "<% \r %>"
endif
if !exists('b:surround_61')
" When using surround `=` (ASCII 61) would provide `<%= selection %>`
let b:surround_61 = "<%= \r %>"
endif
if !exists('b:surround_35')
" When using surround `#` (ASCII 35) would provide `<%# selection %>`
let b:surround_35 = "<%# \r %>"
endif
if !exists('b:surround_123')
" When using surround `{` (ASCII 123) would provide `{{ selection }}`
let b:surround_123 = "{{ \r }}"
endif
if !exists('b:surround_5')
" When using surround `<C-e>` (ASCII 5 `ENQ`) would provide `<% selection %>\n<% end %>`
let b:surround_5 = "<% \r %>\n<% end %>"
endif
setlocal comments=:<%#
setlocal commentstring=<%#\ %s\ %>
let b:undo_ftplugin = "setl cms< " .
\ " | unlet! b:browsefilter b:match_words | " . s:undo_ftplugin
let &cpo = s:save_cpo

52
sources_non_forked/vim-elixir/ftplugin/elixir.vim Normal file
View File

@ -0,0 +1,52 @@
if exists('b:did_ftplugin')
finish
endif
let b:did_ftplugin = 1
" Matchit support
if exists('loaded_matchit') && !exists('b:match_words')
let b:match_ignorecase = 0
let b:match_words = '\:\@<!\<\%(do\|fn\)\:\@!\>' .
\ ':' .
\ '\<\%(else\|elsif\|catch\|after\|rescue\)\:\@!\>' .
\ ':' .
\ '\:\@<!\<end\>' .
\ ',{:},\[:\],(:)'
endif
setlocal shiftwidth=2 softtabstop=2 expandtab iskeyword+=!,?
setlocal comments=:#
setlocal commentstring=#\ %s
let &l:path =
\ join([
\ 'lib/**',
\ 'src/**',
\ 'test/**',
\ 'deps/**/lib/**',
\ 'deps/**/src/**',
\ &g:path
\ ], ',')
setlocal includeexpr=elixir#util#get_filename(v:fname)
setlocal suffixesadd=.ex,.exs,.eex,.heex,.leex,.sface,.erl,.xrl,.yrl,.hrl
let &l:define = 'def\(macro\|guard\|delegate\)\=p\='
silent! setlocal formatoptions-=t formatoptions+=croqlj
let b:block_begin = '\<\(do$\|fn\>\)'
let b:block_end = '\<end\>'
nnoremap <buffer> <silent> <expr> ]] ':silent keeppatterns /'.b:block_begin.'<CR>'
nnoremap <buffer> <silent> <expr> [[ ':silent keeppatterns ?'.b:block_begin.'<CR>'
nnoremap <buffer> <silent> <expr> ][ ':silent keeppatterns /'.b:block_end .'<CR>'
nnoremap <buffer> <silent> <expr> [] ':silent keeppatterns ?'.b:block_end .'<CR>'
onoremap <buffer> <silent> <expr> ]] ':silent keeppatterns /'.b:block_begin.'<CR>'
onoremap <buffer> <silent> <expr> [[ ':silent keeppatterns ?'.b:block_begin.'<CR>'
onoremap <buffer> <silent> <expr> ][ ':silent keeppatterns /'.b:block_end .'<CR>'
onoremap <buffer> <silent> <expr> [] ':silent keeppatterns ?'.b:block_end .'<CR>'
let b:undo_ftplugin = 'setlocal sw< sts< et< isk< com< cms< path< inex< sua< def< fo<'.
\ '| unlet! b:match_ignorecase b:match_words b:block_begin b:block_end'

72
sources_non_forked/vim-elixir/indent/eelixir.vim Normal file
View File

@ -0,0 +1,72 @@
if exists("b:did_indent")
finish
endif
runtime! indent/elixir.vim
unlet! b:did_indent
setlocal indentexpr=
let s:cpo_save = &cpo
set cpo&vim
if exists("b:eelixir_subtype")
exe "runtime! indent/".b:eelixir_subtype.".vim"
else
runtime! indent/html.vim
endif
unlet! b:did_indent
if &l:indentexpr == ''
if &l:cindent
let &l:indentexpr = 'cindent(v:lnum)'
else
let &l:indentexpr = 'indent(prevnonblank(v:lnum-1))'
endif
endif
let b:eelixir_subtype_indentexpr = &l:indentexpr
let b:did_indent = 1
setlocal indentexpr=GetEelixirIndent()
setlocal indentkeys=o,O,*<Return>,<>>,{,},0),0],o,O,!^F,=end,=else,=elsif,=catch,=after,=rescue
" Only define the function once.
if exists("*GetEelixirIndent")
finish
endif
function! GetEelixirIndent(...)
if a:0 && a:1 == '.'
let v:lnum = line('.')
elseif a:0 && a:1 =~ '^\d'
let v:lnum = a:1
endif
let vcol = col('.')
call cursor(v:lnum,1)
let inelixir = searchpair('<%','','%>','W')
call cursor(v:lnum,vcol)
if inelixir && getline(v:lnum) !~ '^<%\|^\s*%>'
let ind = GetElixirIndent()
else
exe "let ind = ".b:eelixir_subtype_indentexpr
endif
let lnum = prevnonblank(v:lnum-1)
let line = getline(lnum)
let cline = getline(v:lnum)
if cline =~# '^\s*<%\s*\%(end\|else\|elsif\|catch\|after\|rescue\)\>.*%>'
let ind -= &sw
elseif line =~# '\S\s*<%\s*end\s*%>'
let ind -= &sw
endif
if line =~# '<%[=%]\=\s*.*\(\<do\|->\)\s*%>' ||
\ line =~# '<%\s*\%(else\|elsif\|catch\|after\|rescue\)\>.*%>'
let ind += &sw
endif
if cline =~# '^\s*%>\s*$'
let ind -= &sw
endif
return ind
endfunction
let &cpo = s:cpo_save
unlet s:cpo_save

15
sources_non_forked/vim-elixir/indent/elixir.vim Normal file
View File

@ -0,0 +1,15 @@
if exists("b:did_indent")
finish
end
let b:did_indent = 1
setlocal indentexpr=elixir#indent(v:lnum)
setlocal indentkeys+==after,=catch,=do,=else,=end,=rescue,
setlocal indentkeys+=*<Return>,=->,=\|>,=<>,0},0],0),>
" TODO: @jbodah 2017-02-27: all operators should cause reindent when typed
function! elixir#indent(lnum)
return elixir#indent#indent(a:lnum)
endfunction

1000
sources_non_forked/vim-elixir/large_file.ex Normal file
View File

File diff suppressed because it is too large Load Diff

64
sources_non_forked/vim-elixir/manual_install.sh Executable file
View File

@ -0,0 +1,64 @@
#!/usr/bin/env bash
exit_whit_error_message() {
printf '%s\n' "$1" >&2
exit 1
}
show_help() {
echo "The script to install the vim-elixir plugin"
echo
echo "Usage: ./manual_install.sh [OPTIONS]"
echo
echo "Options:"
echo "-o, --output-dir string The name of the directory where plugin will be installed. By default the output directory name is 'vim-elixir'"
echo " Example: ./manual_install.sh -o vim-elixir # The plugin will be installed in ~/.vim/pack/vim-elixir/start/vim-elixir directory"
echo " ./manual_install.sh -o elixir-opts # The plugin will be installed in ~/.vim/pack/elixir-opts/start/elixir-opts directory"
echo
}
# Initialize all the option variables.
# This ensures we are not contaminated by variables from the environment.
VIM_PLUGIN_NAME=vim-elixir
while :; do
case $1 in
-h|-\?|--help)
show_help
exit
;;
-o|--output-dir)
if [ "$2" ]; then
VIM_PLUGIN_NAME=$2
shift
else
exit_whit_error_message 'ERROR: "--name" requires a non-empty option argument.'
fi
;;
--output-dir=?*)
# Delete everything up to "=" and assign the remainder.
VIM_PLUGIN_NAME=${1#*=}
;;
--output-dir=) # Handle the case of an empty --name=
exit_whit_error_message 'ERROR: "--name" requires a non-empty option argument.'
;;
-?*)
printf 'WARN: Unknown option (ignored): %s\n' "$1" >&2
;;
*)
# Default case: No more options, so break out of the loop.
break
esac
shift
done
VIM_INSTALL_DIR=~/.vim/pack/$VIM_PLUGIN_NAME/start/$VIM_PLUGIN_NAME
mkdir -p $VIM_INSTALL_DIR
echo "Installing plugin in the ${VIM_INSTALL_DIR} directory"
for DIR in autoload compiler ftdetect ftplugin indent syntax
do
cp -R $DIR $VIM_INSTALL_DIR
done

96
sources_non_forked/vim-elixir/spec/folding/basic_spec.rb Normal file
View File

@ -0,0 +1,96 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Basic folding' do
def self.fold(content)
it("properly folds \n#{content}") do
expect(content).to fold_lines
end
end
fold <<~EOF
defmodule M do # fold
end # fold
"not in fold"
EOF
fold <<~EOF
defmodule M do # fold
def some_func do # fold
end # fold
end # fold
"not in fold"
EOF
fold <<~EOF
defmodule M do
def some_func do # fold
end # fold
end
"not in fold"
EOF
fold <<~EOF
if true do # fold
end # fold
"not in fold"
EOF
fold <<~EOF
if true do # fold
nil # fold
else # fold
nil # fold
end # fold
"not in fold"
EOF
fold <<~EOF
defmodule M do
def some_func do
[ # fold
:hello, # fold
:world # fold
] # fold
:hello_world
end
end
EOF
fold <<~EOF
defmodule M do
def some_func do
{ # fold
:hello, # fold
:world # fold
} # fold
:hello_world
end
end
EOF
fold <<~EOF
defmodule M do
def some_func do
%{ # fold
hello: "a", # fold
world: "b" # fold
} # fold
:hello_world
end
end
EOF
fold <<~EOF
defmodule M do
def some_func do
%User{ # fold
hello: "a", # fold
world: "b" # fold
} # fold
:hello_world
end
end
EOF
end

89
sources_non_forked/vim-elixir/spec/indent/anonymous_functions_spec.rb Normal file
View File

@ -0,0 +1,89 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting anonymous functions' do
i <<~EOF
def do
some_func = fn x -> x end
end
EOF
i <<~EOF
def do
some_func = function do x -> x end
end
EOF
i <<~EOF
def test do
assert_raise Queue.Empty, fn ->
Q.new |> Q.deq!
end
end
EOF
i <<~EOF
defmodule Test do
def lol do
Enum.map([1,2,3], fn x ->
x * 3
end)
end
end
EOF
i <<~EOF
fizzbuzz = fn
0, 0, _ -> "FizzBuzz"
0, _, _ -> "Fizz"
_, 0, _ -> "Buzz"
_, _, x -> x
end
EOF
i <<~EOF
fizzbuzz = function do
0, 0, _ -> "FizzBuzz"
0, _, _ -> "Fizz"
_, 0, _ -> "Buzz"
_, _, x -> x
end
EOF
i <<~EOF
{:ok, 0} = Mod.exec!(cmd, fn progress ->
if event_handler do
event_handler.({:progress_updated, progress})
end
end
)
EOF
i <<~EOF
defp handle_chunk(:err, line, state) do
update_in(state[:stderr], fn
true -> true
false -> false
end)
Map.update(state, :stderr, [line], &(&1 ++ [line]))
end
EOF
i <<~EOF
defp handle_chunk(:err, line, state) do
update_in(state[:stderr], fn
hello -> :ok
world -> :ok
end)
Map.update(state, :stderr, [line], &(&1 ++ [line]))
end
EOF
i <<~EOF
fn ->
end
EOF
end

569
sources_non_forked/vim-elixir/spec/indent/basic_spec.rb Normal file
View File

@ -0,0 +1,569 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Basic indenting' do
i <<~EOF
defmodule Hello do
EOF
i <<~EOF
defmodule Hello do
def some_func do
EOF
i <<~EOF
defmodule Hello do
def some_func do
end
EOF
i <<~EOF
defmodule Hello do
def some_func do
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
IO.puts "hello world"
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
IO.puts "hello world"
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
IO.puts "hello world"
IO.puts "hello world"
IO.puts "hello world"
IO.puts "hello world"
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
if blah? do
blah
else
not_blah
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
if blah? do
blah
else
not_blah
end
if blah? do
blah
else
not_blah
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
IO.puts "hello world"
end
def some_other_func do
if blah? do
blah
if blah? do
blah
else
not_blah
end
else
not_blah
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
cond do
{:abc} -> false
_ -> true
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
cond do
{:abc} -> false
_ -> true
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
cond do
{:abc} ->
say_hello
say_goodbye
_ ->
say_hello
say_goodbye
end
end
end
EOF
i <<~EOF
defmodule Hello.World do
def some_func do
cond do
{:abc} ->
cond do
{:abc} ->
say_hello
say_goodbye
_ ->
say_hello
say_goodbye
end
say_hello
say_goodbye
_ ->
say_hello
say_goodbye
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
case word do
:one -> :two
:high -> :low
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
case word do
:one -> :two
:high -> :low
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
case word do
:one ->
:two
:high ->
:low
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
case word do
:one ->
case word do
:one ->
:two
:high ->
:low
end
:two
:high ->
:low
end
end
end
EOF
i <<~EOF
defmodule Hello do
defmacro hello do
quote do
blah
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
unless blah do
blah
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
if stinky?, do: clean
if smelly?, do: clean
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
name =
"one"
street =
"two"
end
end
EOF
%w(= == === != !== <= >= <> && || + - * / ~~~ ^^^ <<< >>> ||| &&&).each do |bin_op|
i <<~EOF
defmodule Hello do
def hello do
name #{bin_op}
"one"
street #{bin_op}
"two"
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
name #{bin_op} "one"
street #{bin_op} "two"
end
end
EOF
end
i <<~EOF
defmodule Hi do
def hi do
fn hello ->
:world
end
end
end
EOF
i <<~EOF
defmodule Hello do
def hello do
name = "one"
street = "two"
end
end
EOF
i <<~EOF
defmodule Hi do
def hi do
fn hello -> :world end
fn hello -> :world end
end
end
EOF
i <<~EOF
defmodule Hi do
def hi do
fn hello ->
case hello do
:one ->
case word do
:one ->
:two
:high ->
:low
end
:two
:high ->
:low
end
end
end
end
EOF
i <<~EOF
hello =
"str"
|> Pipe.do_stuff
|> Pipe.do_stuff
|> Pipe.do_stuff
|> Pipe.do_stuff(fn ->
more stuff
end)
|> Pipe.do_stuff
EOF
i <<~EOF
defmodule Hi do
defp hi do
:hello
end
defp hi do
:hello
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
[
:one,
:two,
fn ->
:three
end,
:four
]
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
{
:one,
:two,
fn ->
:three
end,
:four
}
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
%Struct{
:one,
:two,
fn ->
:three
end,
:four
}
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
%{
:one,
:two,
fn ->
:three
end,
:four
}
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
try do
raise "boom"
rescue
e in errs ->
IO.puts "one"
_ ->
IO.puts "one"
end
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
try do
raise "wtf"
catch
e ->
IO.puts "one"
_ ->
IO.puts "one"
end
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
receive do
{:hello, world} ->
:ok
after
1000 ->
IO.puts "one"
2000 ->
IO.puts "one"
end
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
receive do
{:hello, world} ->
:ok
_ ->
:err
end
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
fn
:ok ->
IO.puts :ok
_ ->
IO.puts :err
end
end
end
EOF
i <<~EOF
defmodule Hi do
defp hi do
fn
:ok -> IO.puts :ok
_ -> IO.puts :err
end
end
end
EOF
i <<~EOF
fun2 = fn :foo ->
:bar
'end'
end
EOF
i <<~EOF
fun2 = fn :foo ->
:bar
'end'
end
EOF
i <<~EOF
fun3 = fn :foo ->
:bar
:send
end
EOF
i <<~EOF
defmodule Hi do
def hello_world do
"end"
'end'
end
EOF
end

60
sources_non_forked/vim-elixir/spec/indent/binary_operator_spec.rb Normal file
View File

@ -0,0 +1,60 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Binary operators' do
i <<~EOF
word =
"h"
<> "e"
<> "l"
<> "l"
<> "o"
IO.puts word
EOF
i <<~EOF
def hello do
expected = "hello"
<> "world"
IO.puts expected
end
EOF
i <<~EOF
def hello do
expected =
"hello"
<> "world"
IO.puts expected
end
EOF
i <<~EOF
alias Rumbl.Repo
alias Rumbl.Category
for category <- ~w(Action Drama Romance Comedy Sci-fi) do
Repo.get_by(Category, name: category) ||
Repo.insert!(%Category{name: category})
end
EOF
i <<~EOF
data = [
"blah",
"blah2", # *
"blah3"
]
EOF
i <<~EOF
data = [
"blah",
# +
"blah2",
"blah3"
]
EOF
end

109
sources_non_forked/vim-elixir/spec/indent/blocks_spec.rb Normal file
View File

@ -0,0 +1,109 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting blocks' do
i <<~EOF
do
something
end
EOF
i <<~EOF
defmodule Test do
def lol do
IO.inspect :end
end
end
EOF
i <<~EOF
defmodule Hello do
def name, do: IO.puts "bobmarley"
# expect next line starting here
def name(param) do
param
end
end
EOF
i <<~EOF
defmodule Hello do
def name, do: IO.puts "bobmarley"
def name(param) do
param
end
end
EOF
i <<~EOF
def f do
if true, do: 42
end
EOF
i <<~EOF
def f do
x = :do
end
EOF
i <<~EOF
defmodule Test do
def test do
one =
user
|> build_assoc(:videos)
|> Video.changeset()
other =
user2
|> build_assoc(:videos)
|> Video.changeset()
end
end
EOF
i <<~EOF
defmodule MyMod do
def how_are_you do
IO.puts "I'm filling bad :("
IO.puts "really bad"
end
end
EOF
i <<~EOF
defmodule MyMod do
def how_are_you do
"function return"
end
end
EOF
i <<~EOF
scope "/", API do
pipe_through :api # Use the default browser stack
get "/url", Controller, :index
post "/url", Controller, :create
end
EOF
i <<~EOF
def hello do
{:ok, _} = TaskRunner.TaskStore.start_link(name: @task_store)
{:ok, _} = Workspace.start_link
{:ok, pending_task_sup} = TaskRunner.PendingTaskSupervisor.start_link
end
EOF
i <<~EOF
def handle_info(:tick, state = %{policy_iteration: []}) do
state = put_in(state[:policy_iteration], state.policy)
{:noreply, state}
end
EOF
end

111
sources_non_forked/vim-elixir/spec/indent/case_spec.rb Normal file
View File

@ -0,0 +1,111 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting case statements' do
i <<~EOF
case some_function do
:ok ->
:ok
{ :error, :message } ->
{ :error, :message }
end
EOF
i <<~EOF
case Connection.open(rabbitmq) do
{:ok, conn} ->
Woody.info "CONNECTION_SUCCESSFUL"
{:ok, chan} = Channel.open(conn)
{:error, error} ->
Woody.info "CONNECTION_FAILED"
:timer.sleep(10000)
end
EOF
i <<~EOF
defmodule M do
defp _fetch(result, key, deep_key) do
case _fetch(result, key) do
{:ok, val} ->
case _fetch(val, deep_key) do
:error -> {:error, :deep}
res -> res
end
:error -> {:error, :shallow}
end
end
EOF
i <<~EOF
case Connection.open(rabbitmq) do
{:ok, conn} ->
Woody.info "CONNECTION_SUCCESSFUL"
{:ok, chan} = Channel.open(conn)
{:error, error} ->
Woody.info "CONNECTION_FAILED"
:timer.sleep(10000)
end
EOF
i <<~'EOF'
decoded_msg = case JSON.decode(msg) do
{:error, _} ->
a = "a"
b = "dasdas"
">#{a}<>#{b}<"
{:ok, decoded} -> decoded
end
EOF
i <<~EOF
case Repo.insert(changeset) do
{:ok, user} ->
conn
|> put_flash(:info, "%{user.name} created!")
|> redirect(to: user_path(conn, :index))
{:error, changeset} ->
render(conn, "new.html", changeset: changeset)
end
EOF
i <<~EOF
case st do
sym ->
code = if true do
:ok
else
:error
end
Logger.info(code)
st
end
EOF
i <<~EOF
case world do
"apple" ->
IO.puts "its an apple"
IO.puts "no really, its an apple"
"orange" ->
IO.puts "its not an apple"
IO.puts "believe it or not"
end
EOF
i <<~EOF
case o do
a ->
e(fn -> f end)
end
EOF
i <<~EOF
case pattern do
:* -> :ok
_ -> :error
end
EOF
end

56
sources_non_forked/vim-elixir/spec/indent/comment_spec.rb Normal file
View File

@ -0,0 +1,56 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting *after* comments' do
i <<~EOF
# do
IO.puts :test
EOF
i <<~EOF
defmodule Foo do
def run do
list =
File.read!("/path/to/file")
|> String.split()
# now start a new line
# used to start here
# but now starts here
end
end
EOF
i <<~EOF
defmodule Foo do
def run(task) when task in [:t1, :t2] do
end
# now starts a new line
# use to start here
# but now starts here
end
EOF
i <<~EOF
receive do
{{:lock_ready, ^key}, ^pid} ->
after
# NOTE: @jbodah 2017-03-28: we should do some math to adjust the timeout
timeout ->
{:error, :timed_out_waiting_for_lock}
end
EOF
it "bulk indenting comments" do
expect(<<~EOF).to be_elixir_indentation
defmodule Test do
# SELECT *
# FROM table
# WHERE column = 123
# AND another_column = 456
end
EOF
end
end

12
sources_non_forked/vim-elixir/spec/indent/cond_spec.rb Normal file
View File

@ -0,0 +1,12 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting cond statements' do
i <<~EOF
cond do
foo -> 1
bar -> 2
end
EOF
end

28
sources_non_forked/vim-elixir/spec/indent/def_spec.rb Normal file
View File

@ -0,0 +1,28 @@
require 'spec_helper'
describe 'def indentation' do
i <<~EOF
def handle_call({:release_lock, key}, _from, state) do
case get_lock(state, key) do
nil ->
{:reply, {:error, :already_unlocked}, state}
_ ->
new_state = delete_lock(state, key)
{:reply, :ok, new_state}
end
end
def
EOF
i <<~EOF
defmodule Hello do
def hello do
end
#{"\n" * 40}
def world do
end
end
EOF
end

34
sources_non_forked/vim-elixir/spec/indent/documentation_spec.rb Normal file
View File

@ -0,0 +1,34 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting documentation' do
i <<~EOF
defmodule Test do
@doc """
end
"""
end
EOF
it "bulk indenting doc blocks" do
expect(<<~EOF).to be_elixir_indentation
defmodule Test do
@doc """
do not reindent
any indent that i do
please
"""
end
EOF
end
i <<~EOF
defmodule Test do
@doc """
it should
have reasonable
default start indent when typed
"""
EOF
end

45
sources_non_forked/vim-elixir/spec/indent/ecto_queries_spec.rb Normal file
View File

@ -0,0 +1,45 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting Ecto queries' do
i <<~EOF
defmodule New do
def do_query do
from user in Users,
select: user.name,
join: signup in Signups, where: user.id == signup.user_id
end
end
EOF
i <<~EOF
def smth do
from = 1
to = 7
end
EOF
i <<~EOF
fromin,
EOF
i <<~EOF
query = from u in query, select: u.city
EOF
i <<~EOF
def do_query do
where = [category: "fresh and new"]
order_by = [desc: :published_at]
select = [:id, :title, :body]
from Post, where: ^where, order_by: ^order_by, select: ^select
end
EOF
i <<~EOF
def alphabetical(query) do
from c in query, order_by: c.name
end
EOF
end

26
sources_non_forked/vim-elixir/spec/indent/ecto_spec.rb Normal file
View File

@ -0,0 +1,26 @@
require 'spec_helper'
describe 'EctoEnum' do
i <<~EOF
defmodule Onemedical.Types do
import EctoEnum
defenum(Work.Occupation, :work_occupation, [
:actor, :architect, :athlete, :baker, :bank_clerk, :banker, :barber, :blogger,
:bricklayer, :broadcaster, :builder, :captain, :carpenter, :choreographer,
:computer_engineer, :computer_programmer, :custom_officer, :dancer, :designer,
:director, :doctor, :driver, :editor, :entertainer, :engineer, :facility_manager,
:farmer, :fashion_designer, :geologist, :goldsmith, :graphic_designer, :hairdresser,
:host_hostess, :house_girl, :interior_designer, :judge, :land_surveyor, :lecturer,
:make_up_artist, :manager, :mechanic, :midwife, :model, :music_director, :musician,
:nanny, :nurse, :pastor, :paediatrician, :photographer, :physicist, :pilot, :plumber,
:police_officer, :printer, :producer, :publisher, :quality_inspector, :radiographer,
:real_estate_agent, :referee, :refuse_collector, :registrar, :safety_engineer, :sales_manager,
:script_writer, :secretary, :security_guard, :shoemaker, :songwriter, :sound_engineer,
:stock_broker, :surveyor, :tailor, :teacher, :telecommunications_engineer, :usher,
:waiter, :writer, :zookeeper, :other])
defenum(Work.Type, :work_type, [
:full_time, :part_time, :volunteer, :temporary
])
end
EOF
end

31
sources_non_forked/vim-elixir/spec/indent/embedded_elixir_spec.rb Normal file
View File

@ -0,0 +1,31 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting eelixir' do
it 'anonymous function' do
expect(<<~EOF).to be_eelixir_indentation
<%= form_for @changeset, user_path(@conn, :create), fn f -> %>
It is obviously true
<% end %>
EOF
end
it 'if..do..end' do
expect(<<~EOF).to be_eelixir_indentation
<%= if true do %>
It is obviously true
<% end %>
EOF
end
it 'if..do..else..end' do
expect(<<~EOF).to be_eelixir_indentation
<%= if true do %>
It is obviously true
<% else %>
This will never appear
<% end %>
EOF
end
end

263
sources_non_forked/vim-elixir/spec/indent/embedded_views_spec.rb Normal file
View File

@ -0,0 +1,263 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting embedded views' do
i <<~EOF
def render(assigns) do
~L"""
<div>
Some content
</div>
"""
end
EOF
i <<~EOF
def render(assigns) do
~H"""
<div class="theres a-/ in the class names from tailwind">
<div class="some more classes">
This is immediately nested
<div>
<input type="number" value="2" />
There's a self-closing tag
</div>
</div>
</div>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<div id="123456">
Some content
</div>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<div
id="123456"
>
Some content
</div>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<div />
<p>Some paragraph</p>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<div>
it
<div>
keeps
<div>
nesting
</div>
</div>
</div>
"""
end
EOF
i <<~EOF
def render(assgins) do
~L"""
<div>
<%= for i <- iter do %>
<div><%= i %></div>
<% end %>
</div>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<%= live_component @socket,
Component,
id: "<%= @id %>",
user: @user do
%>
<main>
<header>
<h1>Some Header</h1>
</header>
<section>
<h1>Some Section</h1>
<p>
I'm some text
</p>
</section>
</main>
<% end %>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<%= render_component,
@socket,
Component do %>
<p>Multi-line opening eex tag that takes a block</p>
<% end %>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<div>
<%= render_component,
@socket,
Component %>
</div>
<%= render_component,
@socket,
Component %>
<p>Multi-line single eex tag</p>
"""
end
EOF
i <<~EOF
def render(assigns) do
~H"""
<Component
foo={{
foo: [
'one',
'two',
'three'
],
bar: %{
"foo" => "bar"
}
}}
/>
"""
end
EOF
i <<~EOF
def render(assigns) do
~L"""
<%= live_component @socket,
Component,
id: "<%= @id %>",
team: @team do
%>
<div>
<div>
<div>
A deeply nested tree
<div>
with trailing whitespace
</div>
</div>
</div>
</div>
<div id="id-ends-with-greater-than->"
propWithEexTag="<%= @id %>"
anotherProp="foo"
/>
<%= for i <- iter do %>
<div><%= i %></div>
<% end %>
<div
opts={{
opt1: "optA",
opt2: "optB"
}}
id="hi"
bye="hi" />
<ul>
<li :for={{ item <- @items }}>
{{ item }}
</li>
</ul>
<div id="hi">
Hi <p>hi</p>
I'm ok, ok?
<div>
hi there!
</div>
<div>
<div>
<p>hi</p>
<hr />
</div>
</div>
</div>
<Some.Surface.Component />
<Another
prop="prop"
prop2="prop2"
>
<div>content</div>
</Another>
<div foo />
<div>hi</div>
<div>
<div>
content
</div>
<div />
<div>
content in new div after a self-closing div
</div>
</div>
<p
id="<%= @id %>"
class="multi-line opening single letter p tag"
>
<%= @solo.eex_tag %>
<Nested
prop="nested"
>
content
</Nested>
</p>
<% end %>
"""
end
EOF
end

32
sources_non_forked/vim-elixir/spec/indent/exunit_spec.rb Normal file
View File

@ -0,0 +1,32 @@
require 'spec_helper'
describe 'exunit' do
i <<~EOF
test "test" do
Mod.fun(fn ->
map = %Mod.Map{
id: "abc123",
state: "processing",
submod: %Mod.Submod{
options: %{}
}
}
EOF
i <<~EOF
test "test" do
Mod.fun(fn ->
map = %Mod.Map{
id: "abc123",
fun: fn ->
IO.inspect :hello
IO.inspect %{
this_is: :a_map
}
end,
submod: %Mod.Submod{
options: %{}
}
}
EOF
end

41
sources_non_forked/vim-elixir/spec/indent/if_spec.rb Normal file
View File

@ -0,0 +1,41 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting if clauses' do
i <<~EOF
if foo do
bar
end
EOF
i <<~EOF
if foo do
bar
else
baz
end
EOF
i <<~EOF
def test do
"else"
end
EOF
i <<~EOF
if true do
else
end
EOF
i <<~EOF
def exec(command, progress_func \\ fn(_, state) -> state end, key \\ nil, output \\ nil) do
if key do
with_cache(key, output, fn -> do_exec(command, progress_func) end)
else
do_exec(command, progress_func)
end
end
EOF
end

29
sources_non_forked/vim-elixir/spec/indent/keyword_spec.rb Normal file
View File

@ -0,0 +1,29 @@
require 'spec_helper'
describe 'Keywords' do
i <<~EOF
def handle_call({:get_in_line_for_lock, key}, from, state) do
queue = state[:queues][key] || :queue.new
queue = queue.in(from, queue)
hello
end
EOF
# Has cond in milliseconds
i <<~EOF
if arg[:arg] do
finish_time = Timex.Duration.now
start_time = Mod.Mod.arg(@attr, fun(state))
duration = Timex.Duration.diff(finish_time, start_time, :milliseconds)
Mod.fun(:arg, arg, arg: arg, arg: arg, arg)
e
EOF
i <<~EOF
Logger.metadata(
task_id: state.recipe.task_id,
hashed_id: state.recipe.config.some_id,
task
)
EOF
end

205
sources_non_forked/vim-elixir/spec/indent/lists_spec.rb Normal file
View File

@ -0,0 +1,205 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting lists' do
i <<~EOF
def example do
[ :foo,
:bar,
:baz ]
end
EOF
i <<~EOF
[
[
:foo
]
]
EOF
i <<~EOF
def project do
[ name: "mix",
version: "0.1.0",
deps: deps ]
end
EOF
i <<~EOF
def config do
[ name:
"John" ]
end
EOF
i <<~EOF
def test do
[ { :cowboy, github: "extend/cowboy" },
{ :dynamo, "0.1.0-dev", github: "elixir-lang/dynamo" },
{ :ecto, github: "elixir-lang/ecto" },
{ :pgsql, github: "semiocast/pgsql" } ]
end
EOF
i <<~EOF
def test do
[ [:a, :b, :c],
[:d, :e, :f] ]
end
EOF
i <<~EOF
def test do
[ app: :first,
version: "0.0.1",
dynamos: [First.Dynamo],
compilers: [:elixir, :dynamo, :ecto, :app],
env: [prod: [compile_path: "ebin"]],
compile_path: "tmp/first/ebin",
deps: deps ]
end
EOF
i <<~EOF
def project do
[
{ :bar, path: "deps/umbrella/apps/bar" },
{ :umbrella, path: "deps/umbrella" }
]
end
EOF
i <<~EOF
def test do
a = [
%{
foo: 1,
bar: 2
}
]
b = %{
[
:foo,
:bar
]
}
[
a,
b
]
end
EOF
i <<~EOF
def create(conn, %{
"grant_type" => "password",
"username" => username,
"password" => password
}) do
1
end
EOF
i <<~EOF
def double(x) do
add(
x,
y
)
end
EOF
i <<~EOF
def double(x) do
add(
x,
y,
w,
z
)
end
EOF
i <<~EOF
def double(x) do
result = add(
x,
z
)
div(result, 2)
end
EOF
i <<~EOF
defmodule Module do
@person1 { name: "name",
age: 18,
enabled?: true }
@person2 { name: "other name",
age: 21,
enabled?: false }
end
EOF
i <<~EOF
def test_another_feature do
assert json_response(conn, 200) == %{
"results" => [
%{
"id" => result.id,
}
]
}
end
EOF
i <<~EOF
defmodule Mod do
def test do
foo == %{
}
assert json_response == %{
"id" => "identifier"
}
end
end
EOF
i <<~EOF
defmodule Mod do
def fun do
json_logger = Keyword.merge(Application.get_env(:logger, :json_logger, []), options)
Application.put_env(:logger, :json_logger, json_logger)
level = Keyword.get(json_logger, :level)
%{level: level, output: :console}
end
end
EOF
i <<~EOF
defmodule Mod do
def fun do
Enum.each(s.routing_keys, fn k -> Queue.bind(chan, s.queue, s.exchange, routing_key: k) end)
Basic.consume(chan, s.queue, nil, no_ack: true)
end
end
EOF
i <<~EOF
def init(_) do
children = [
worker(QueueSet, [[name: @queue_set]]),
worker(Producer, [[name: @producer]]),
worker(ConsumerSupervisor, [[{@producer, max_demand: @max_executors}]])
]
supervise(children, strategy: :one_for_one)
end
EOF
end

13
sources_non_forked/vim-elixir/spec/indent/macro_spec.rb Normal file
View File

@ -0,0 +1,13 @@
require 'spec_helper'
describe 'Macros' do
i <<~EOF
defmodule DeadboltTest do
use ExUnit.Case
doctest Deadbolt
hello
end
EOF
end

47
sources_non_forked/vim-elixir/spec/indent/map_spec.rb Normal file
View File

@ -0,0 +1,47 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Map indent' do
i <<~'EOF'
DrMock.mock(fn ->
params = %{
}
end)
EOF
i <<~EOF
x = %{
foo: :bar
}
y = :foo
EOF
i <<~EOF
x =
%{ foo: :bar }
y = :foo
EOF
i <<~EOF
x = %{
foo: :bar }
y = :foo
EOF
i <<~EOF
test "test" do
Mod.fun(fn ->
map = %Mod.Map{
id: "abc123",
state: "processing",
submod: %Mod.Submod{
options: %{}
}
}
EOF
end

145
sources_non_forked/vim-elixir/spec/indent/pipeline_spec.rb Normal file
View File

@ -0,0 +1,145 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting pipeline' do
i <<~EOF
"a,b,c,d"
|> String.split(",")
|> Enum.reverse
EOF
i <<~EOF
[ h | t ] = "a,b,c,d"
|> String.split(",")
|> Enum.reverse
EOF
i <<~EOF
def test do
[ h | t ] = "a,b,c,d"
|> String.split(",")
|> Enum.reverse
{ :ok, h }
end
EOF
i <<~EOF
def test do
my_post = Post
|> where([p], p.id == 10)
|> where([p], u.user_id == 1)
|> select([p], p)
end
EOF
i <<~EOF
def test do
"a,b,c,d"
|> String.split(",")
|> Enum.first
|> case do
"a" -> "A"
_ -> "Z"
end
end
EOF
i <<~EOF
defrecord RECORD, field_a: nil, field_b: nil
rec = RECORD.new
|> IO.inspect
EOF
i <<~EOF
defmodule MyMod do
def export_info(users) do
{:ok, infos} = users
|> Enum.map(fn (u) -> do_something(u) end)
|> Enum.map(fn (u) ->
do_even_more(u)
end)
|> finall_thing
infos
end
end
EOF
i <<~EOF
def build_command(input, output) do
"embedded=here"
|>
end
EOF
i <<~EOF
def build_command(input, output) do
'embedded=here'
|>
EOF
i <<~EOF
def build_command(input, output) do
%{:hello => :world}
|>
end
EOF
%w(<= >= == != === !== =~).each do |op|
i <<~EOF
def build_command(input, output) do
true #{op} false
|> IO.inspect
end
EOF
end
i <<~EOF
upcased_names = names
|> Enum.map(fn name ->
String.upcase(name)
end)
IO.inspect names
EOF
i <<~EOF
upcased_names = names
|> Enum.map(fn name ->
String.upcase(name) end)
IO.inspect names
EOF
i <<~EOF
upcased_names = names
|> Enum.map(fn name ->
String.upcase(name)
end)
|> do_stuff
EOF
i <<~EOF
def hello do
do_something
|> Pipe.to_me
{:ok}
end
EOF
i <<~EOF
defmodule MyModule do
def do_stuff do
name =
"Dr. Zaius"
|> determine_name
hello
end
end
EOF
end

22
sources_non_forked/vim-elixir/spec/indent/receive_spec.rb Normal file
View File

@ -0,0 +1,22 @@
require 'spec_helper'
describe 'receive indent' do
i <<~EOF
receive do
after
end
EOF
i <<~EOF
def obtain_lock(pid, key, timeout \\ 60_000) do
case GenServer.call(pid, {:obtain_lock, key}) do
:will_notify ->
receive do
after
timeout ->
end
res -> res
end
end
EOF
end

18
sources_non_forked/vim-elixir/spec/indent/string_spec.rb Normal file
View File

@ -0,0 +1,18 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting strings' do
it "bulk indenting strings" do
expect(<<~EOF).to be_elixir_indentation
defp sql do
"""
SELECT *
FROM table
WHERE column = 123
AND another_column = 456
"""
end
EOF
end
end

23
sources_non_forked/vim-elixir/spec/indent/struct_spec.rb Normal file
View File

@ -0,0 +1,23 @@
require 'spec_helper'
describe 'defstruct' do
i <<~EOF
defmodule A do
defmodule State do
defstruct field: nil, field: nil, field: nil,
field: [], field: nil, field: 0,
field: false, field: %{}
end
defmodule State do
defstruct field: nil, field: nil, field: nil
end
defmodule State do
defstruct field: nil,
field: [],
field: false
end
end
EOF
end

41
sources_non_forked/vim-elixir/spec/indent/try_spec.rb Normal file
View File

@ -0,0 +1,41 @@
require 'spec_helper'
describe 'try indent' do
i <<~EOF
try do
rescue
end
EOF
i <<~EOF
try do
catch
end
EOF
i <<~EOF
try do
after
end
EOF
i <<~EOF
test "it proceses the command" do
out = "testfile"
try do
cmd = "thing \#{@test_file} \#{out}"
{:ok, 0, _} = Thing.exec(cmd)
after
File.rm!(out)
end
end
EOF
i <<~EOF
try do
foo()
else
value -> value
end
EOF
end

29
sources_non_forked/vim-elixir/spec/indent/tuples_spec.rb Normal file
View File

@ -0,0 +1,29 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Indenting tuples' do
i <<~EOF
def xpto do
{ :a,
:b,
:c }
end
EOF
i <<~EOF
def method do
{
:bar,
path: "deps/umbrella/apps/bar"
}
end
EOF
i <<~EOF
x = [
{:text, "asd {"},
{:text, "qwe"},
]
EOF
end

121
sources_non_forked/vim-elixir/spec/indent/with_spec.rb Normal file
View File

@ -0,0 +1,121 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'with' do
i <<~EOF
with {:ok, msg} <- Msgpax.unpack(payload) do
{:ok, rebuild(msg)}
else
error -> error
end
EOF
i <<~EOF
with {:ok, width} <- Map.fetch(opts, :width),
double_width = width * 2,
{:ok, height} <- Map.fetch(opts, :height)
do
{:ok, double_width * height}
end
EOF
i <<~EOF
with {:ok, width} <- Map.fetch(opts, :width),
double_width = width * 2,
{:ok, height} <- Map.fetch(opts, :height),
do: {:ok, double_width * height}
EOF
i <<~EOF
with {:ok, width} <- Map.fetch(opts, :width),
{:ok, height} <- Map.fetch(opts, :height)
do
{:ok, width * height}
else
:error ->
{:error, :wrong_data}
end
EOF
i <<~EOF
with {:ok, width} <- Map.fetch(opts, :width),
{:ok, height} <- Map.fetch(opts, :height),
do:
{:ok,
width * height * height * height * height * height * height * height * height * height *
height * height * height * height * height * height * height},
else: (:error -> {:error, :wrong_data})
EOF
i <<~'EOF'
# This file is responsible for configuring your application
# and its dependencies with the aid of the Mix.Config module.
use Mix.Config
import_config "#{Mix.env}.exs"
EOF
i <<~'EOF'
with {:ok, %File.Stat{size: size}} when size > 0 <- File.stat(first_frame_path) do
File.rename(first_frame_path, output_path)
{:ok, %Result{path: output_path}}
else
error ->
{:error, error}
end
EOF
i <<~'EOF'
def resend_confirmation(username) when is_binary(username) do
with user = %User{confirmed_at: nil} <- get_by(username: username) do
{:ok, user} =
user
|> DB.add_confirm_token
|> update_user()
Log.info(%Log{user: user.id, message: "send new confirmation"})
send_welcome(user)
{:ok, user}
else
nil ->
{:error, "not found"}
%User{email: email} ->
Email.already_confirmed(email)
{:error, "already confirmed"}
end
end
EOF
i <<~'EOF'
def create_user(params) do
profile = UserProfile.registration_changeset(%UserProfile{}, params)
user_cs =
%User{}
|> User.registration_changeset(params)
|> put_assoc(:user_profile, profile)
with {:ok, user} <- Repo.insert(user_cs, returning: false) do
Log.info(%Log{user: user.id, message: "user created"})
send_welcome(user)
{:ok, user}
end
end
EOF
i <<~'EOF'
def my_function do
with :ok <- some_call,
:ok <- another_call do
end
end
EOF
i <<~'EOF'
with {:ok, foo} <- thing(1),
{:ok, bar} <- thing(2) do
foo + bar
end
EOF
end

322
sources_non_forked/vim-elixir/spec/spec_helper.rb Normal file
View File

@ -0,0 +1,322 @@
require 'rspec/expectations'
require 'tmpdir'
require 'vimrunner'
require 'vimrunner/rspec'
GVIM_PATH_FILE = File.expand_path('../../.gvim_path', __FILE__)
class Buffer
FOLD_PLACEHOLDER = '<!-- FOLD -->'.freeze
def initialize(vim, type)
@file = ".fixture.#{type}"
@vim = vim
end
def reindent(content)
with_file content do
min_indent = content.each_line.map { |line| line[/\s*/].size }.min
cmd = "ggVG:s/\\s\\{0,#{min_indent}}//" # remove all indentation
cmd += 'gg=G' # force vim to indent the file
@vim.normal cmd
end
end
def type(content)
with_file do
@vim.normal 'gg'
lines = content.each_line
count = lines.count
@vim.type("i")
lines.each_with_index do |line, index|
@vim.type("#{line.strip}")
@vim.type("<CR>") if index < count - 1
end
end
end
def syntax(content, pattern)
with_file content
# Using this function with a `pattern` that is not in `content` is pointless.
#
# @vim.search() silently fails if a pattern is not found and the cursor
# won't move. So, if the current cursor position happens to sport the
# expected syntax group already, this can lead to false positive tests.
#
# We work around this by using Vim's search() function, which returns 0 if
# there is no match.
if @vim.echo("search(#{pattern.inspect})") == '0'
return []
end
syngroups = @vim.echo <<~EOF
map(synstack(line('.'), col('.')), 'synIDattr(v:val, "name")')
EOF
# From: "['elixirRecordDeclaration', 'elixirAtom']"
# To: ["elixirRecordDeclaration", "elixirAtom"]
syngroups.gsub!(/["'\[\]]/, '').split(', ')
end
def fold_and_replace(content, fold_on_line)
with_file content do
cmd = ":set foldmethod=syntax<CR>"
cmd += "zO"
cmd += "#{fold_on_line}G"
cmd += "zc"
cmd += "cc#{FOLD_PLACEHOLDER}<Esc>"
cmd += ":.s/\s*//<CR>"
@vim.normal(cmd)
end
end
private
def with_file(content = nil)
edit_file(content)
yield if block_given?
@vim.normal ":w<CR>"
@vim.normal ":redraw<CR>"
IO.read(@file)
end
def edit_file(content)
File.write(@file, content) if content
@vim.edit @file
end
end
class Differ
def self.diff(result, expected)
instance.diff(result, expected)
end
def self.instance
@instance ||= new
end
def initialize
@differ = RSpec::Support::Differ.new(
object_preparer: -> (object) do
RSpec::Matchers::Composable.surface_descriptions_in(object)
end,
color: RSpec::Matchers.configuration.color?
)
end
def diff(result, expected)
@differ.diff_as_string(result, expected)
end
end
module ExBuffer
def self.new
Buffer.new(VIM, :ex)
end
end
module EexBuffer
def self.new
Buffer.new(VIM, :eex)
end
end
module HeexBuffer
def self.new
Buffer.new(VIM, :heex)
end
end
module LeexBuffer
def self.new
Buffer.new(VIM, :leex)
end
end
module SurfaceBuffer
def self.new
Buffer.new(VIM, :sface)
end
end
RSpec::Matchers.define :be_typed_with_right_indent do |syntax|
buffer = Buffer.new(VIM, syntax || :ex)
match do |code|
@typed = buffer.type(code)
@typed == code
end
failure_message do |code|
<<~EOM
Expected
#{@typed}
to be indented as
#{code}
when typed
EOM
end
end
{
be_elixir_indentation: :ex,
be_eelixir_indentation: :eex,
be_heelixir_indentation: :heex,
be_leelixir_indentation: :leex,
be_surface_indentation: :sface
}.each do |matcher, type|
RSpec::Matchers.define matcher do
buffer = Buffer.new(VIM, type)
match do |code|
reindented = buffer.reindent(code)
reindented == code
end
failure_message do |code|
<<~EOM
Expected
#{buffer.reindent(code)}
to be indented as
#{code}
when bulk indented
EOM
end
end
end
{
include_elixir_syntax: :ex,
include_eelixir_syntax: :eex,
include_heelixir_syntax: :heex,
include_leelixir_syntax: :leex,
include_surface_syntax: :sface
}.each do |matcher, type|
RSpec::Matchers.define matcher do |syntax, pattern|
buffer = Buffer.new(VIM, type)
match do |code|
buffer.syntax(code, pattern).include? syntax.to_s
end
failure_message do |code|
<<~EOF
expected #{buffer.syntax(code, pattern)}
to include syntax '#{syntax}'
for pattern: /#{pattern}/
in:
#{code}
EOF
end
failure_message_when_negated do |code|
<<~EOF
expected #{buffer.syntax(code, pattern)}
*NOT* to include syntax '#{syntax}'
for pattern: /#{pattern}/
in:
#{code}
EOF
end
end
end
RSpec::Matchers.define :fold_lines do
buffer = Buffer.new(VIM, :ex)
match do |code|
@code = code
pattern = /# fold\s*$/
placeholder_set = false
@expected = code.each_line.reduce([]) do |acc, line|
if line =~ pattern
if !placeholder_set
placeholder_set = true
acc << (Buffer::FOLD_PLACEHOLDER + "\n")
end
else
acc << line
end
acc
end.join
fold_on_line = code.each_line.find_index { |l| l =~ pattern } + 1
@actual = buffer.fold_and_replace(code, fold_on_line)
@expected == @actual
end
failure_message do |code|
<<~EOF
Folded
#{@code}
and unexpectedly got
#{@actual}
EOF
end
end
Vimrunner::RSpec.configure do |config|
config.reuse_server = true
config.start_vim do
VIM =
if File.exists?(GVIM_PATH_FILE)
Vimrunner::Server.new(executable: File.read(GVIM_PATH_FILE).rstrip).start
else
Vimrunner.start_gvim
end
VIM.add_plugin(File.expand_path('..', __dir__))
cmd = ':filetype off<CR>'
cmd += ':filetype plugin indent on<CR>'
cmd += ':autocmd FileType * setlocal formatoptions-=c formatoptions-=r formatoptions-=o<CR>' # disable automatic comment continuation
cmd += ":set ignorecase<CR>" # make sure we test ignorecase
VIM.normal(cmd)
VIM
end
end
RSpec.configure do |config|
config.order = :random
# Run a single spec by adding the `focus: true` option
config.filter_run_including focus: true
config.run_all_when_everything_filtered = true
end
RSpec::Core::ExampleGroup.instance_eval do
def i(str)
gen_tests(:it, str)
end
def ip(str)
gen_tests(:pending, str)
end
private
def gen_tests(method, str)
send method, "\n#{str}" do
expect(str).to be_elixir_indentation
end
send method, "typed: \n#{str}" do
expect(str).to be_typed_with_right_indent
end
end
end

48
sources_non_forked/vim-elixir/spec/syntax/alias_spec.rb Normal file
View File

@ -0,0 +1,48 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Alias syntax' do
it 'colorize only module alias' do
str = "Enum.empty?(...)"
expect(str).to include_elixir_syntax('elixirAlias', 'Enum')
expect(str).to include_elixir_syntax('elixirOperator', '\.')
expect(str).to include_elixir_syntax('elixirId', 'empty?')
end
it 'colorize the module alias even if it starts with `!`' do
expect(<<~EOF).to include_elixir_syntax('elixirAlias', 'Enum')
!Enum.empty?(...)
EOF
end
it 'does not colorize the preceding ! in an alias' do
expect(<<~EOF).not_to include_elixir_syntax('elixirAlias', '!')
!Enum.empty?(...)
EOF
end
it 'does not colorize words starting with lowercase letters' do
expect(<<~EOF).not_to include_elixir_syntax('elixirAlias', 'aEnum')
aEnum.empty?(...)
EOF
end
it 'colorizes numbers in aliases' do
str = "S3Manager"
expect(str).to include_elixir_syntax('elixirAlias', 'S')
expect(str).to include_elixir_syntax('elixirAlias', '3')
expect(str).to include_elixir_syntax('elixirAlias', 'Manager')
end
it 'colorize dots in module alias' do
str = "Foo.Bar.Baz.fun(...)"
expect(str).to include_elixir_syntax('elixirAlias', 'Foo')
expect(str).to include_elixir_syntax('elixirAlias', '\.\(Bar\)\@=')
expect(str).to include_elixir_syntax('elixirAlias', 'Bar')
expect(str).to include_elixir_syntax('elixirAlias', '\.\(Baz\)\@=')
expect(str).to include_elixir_syntax('elixirAlias', 'Baz')
expect(str).to include_elixir_syntax('elixirOperator', '\.\(fun\)\@=')
expect(str).to include_elixir_syntax('elixirId', 'fun')
end
end

32
sources_non_forked/vim-elixir/spec/syntax/anonymous_function_spec.rb Normal file
View File

@ -0,0 +1,32 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Anonymous function syntax' do
it 'anonymous function' do
expect(<<~'EOF').to include_elixir_syntax('elixirAnonymousFunction', 'fn')
fn(_, state) -> state end
EOF
end
it 'as a default argument' do
expect(<<~'EOF').to include_elixir_syntax('elixirAnonymousFunction', 'fn')
def exec(func \\ fn(_, state) -> state end) do
end
EOF
end
it 'as a default argument in a module' do
str = <<~'EOF'
defmodule HelloWorld do
def exec(func \\ fn(_, state) -> state end) do
end
end
EOF
expect(str).to include_elixir_syntax('elixirAnonymousFunction', 'fn')
# Test that the syntax properly closed
expect(str).to include_elixir_syntax('elixirBlockDefinition', '^end')
end
end

91
sources_non_forked/vim-elixir/spec/syntax/atom_spec.rb Normal file
View File

@ -0,0 +1,91 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Atom syntax' do
KEYWORDS = %w(
def
defp
defmodule
defprotocol
defimpl
defrecord
defrecordp
defmacro
defmacrop
defdelegate
defoverridable
defexception
defcallback
defstruct
)
it '`atom:` style keyword used as an atom' do
KEYWORDS.each do |kw|
expect(<<~EOF).to include_elixir_syntax('elixirAtom', kw), "expected #{kw} to be an elixirAtom"
defmodule XmlElement do
require Record
import Record, only: [#{kw}: 2, extract: 2]
end
EOF
end
end
it '`:atom =>` style keyword used as an atom' do
KEYWORDS.each do |kw|
expect(<<~EOF).to include_elixir_syntax('elixirAtom', kw), "expected #{kw} to be an elixirAtom"
defmodule XmlElement do
require Record
import Record, only: [:#{kw} => 2, :extract => 2]
end
EOF
end
end
it 'atoms as part of a comprehension' do
s = 'for kvp <- map, do: &atomize_key/1, into: %{}'
expect(s).to include_elixir_syntax('elixirAtom', 'do')
expect(s).to include_elixir_syntax('elixirAtom', 'into')
end
it 'defoverridable' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', 'init:')
defmodule Test do
defmacro __using__(_options) do
quote do
def init(args) do
{:ok, args}
end
defoverridable init: 1
end
end
end
EOF
expect(<<~EOF).to include_elixir_syntax('elixirAtom', 'init:')
defmodule Test do
defmacro __using__(_options) do
quote do
def init(args) do
{:ok, args}
end
defoverridable [init: 1]
end
end
end
EOF
end
it '`Atom:` style atoms used in keyword list' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', 'Protocols:')
def project do
[
docs: [
groups_for_modules: [
Protocols: [Enumerable],
]
]
]
end
EOF
end
end

14
sources_non_forked/vim-elixir/spec/syntax/case_spec.rb Normal file
View File

@ -0,0 +1,14 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Syntax case statements' do
it ':* is recognized as an atom' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', '\*')
case pattern do
:* -> :ok
_ -> :error
end
EOF
end
end

32
sources_non_forked/vim-elixir/spec/syntax/comments_spec.rb Normal file
View File

@ -0,0 +1,32 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Comments syntax' do
it 'full line comment' do
expect(<<~EOF).to include_elixir_syntax('elixirComment', '#\ this\ is\ a\ comment')
# this is a comment
EOF
end
it 'end line comment' do
expect(<<~EOF).to include_elixir_syntax('elixirComment', '#\ this\ is\ a\ comment')
IO.puts "some text" # this is a comment
EOF
end
it 'after arguments' do
t = <<~EOF
def foo(<<
0 :: 1, # Foo
1 :: size(1), # Bar
# Blah
baz :: 8, # Baz
>>), do: baz
EOF
expect(t).to include_elixir_syntax('elixirComment', '#\ Foo')
expect(t).to include_elixir_syntax('elixirComment', '#\ Bar')
expect(t).to include_elixir_syntax('elixirComment', '#\ Blah')
expect(t).to include_elixir_syntax('elixirComment', '#\ Baz')
end
end

30
sources_non_forked/vim-elixir/spec/syntax/defmodule_spec.rb Normal file
View File

@ -0,0 +1,30 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Defmodule syntax' do
it 'defines `defmodule` keyword as elixirModuleDefine' do
expect(<<~EOF).to include_elixir_syntax('elixirModuleDefine', 'defmodule')
defmodule HelloPhoenix.HelloController do
EOF
end
it 'defines module name as elixirModuleDeclaration' do
str = "defmodule HelloPhoenix.HelloController do"
expect(str).to include_elixir_syntax('elixirModuleDeclaration', 'HelloPhoenix')
expect(str).to include_elixir_syntax('elixirModuleDeclaration', '\.')
expect(str).to include_elixir_syntax('elixirModuleDeclaration', 'HelloController')
end
it 'does not define module name as elixirAlias' do
expect(<<~EOF).not_to include_elixir_syntax('elixirAlias', 'HelloPhoenix.HelloController')
defmodule HelloPhoenix.HelloController do
EOF
end
it 'defines `do` keyword as elixirBlock' do
expect(<<~EOF).to include_elixir_syntax('elixirBlock', 'do')
defmodule HelloPhoenix.HelloController do
EOF
end
end

218
sources_non_forked/vim-elixir/spec/syntax/doc_spec.rb Normal file
View File

@ -0,0 +1,218 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'documentation syntax' do
describe 'string' do
it 'doc in double quotes' do
ex = '@doc "foo"'
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
expect(ex).to include_elixir_syntax('elixirDocStringDelimiter', '"')
end
it 'doc in sigil_S' do
ex = '@doc ~S(foo)'
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
expect(ex).to include_elixir_syntax('elixirDocSigilDelimiter', 'S')
end
end
describe 'heredoc' do
it 'doc with multiline content' do
ex = <<~'EOF'
@callbackdoc """
foo
"""
EOF
expect(ex).to include_elixir_syntax('elixirVariable', 'doc')
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
expect(ex).to include_elixir_syntax('elixirDocStringDelimiter', '"""')
end
it 'doc with sigil_S triple double-quoted multiline content' do
ex = <<~'EOF'
@doc ~S"""
foo
"""
EOF
expect(ex).to include_elixir_syntax('elixirVariable', 'doc')
expect(ex).to include_elixir_syntax('elixirDocSigilDelimiter', 'S"""')
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
end
it 'doc with sigil_S triple double-quoted multiline content with parentheses' do
ex = <<~'EOF'
@doc(~S"""
foo
""")
EOF
expect(ex).to include_elixir_syntax('elixirVariable', 'doc')
expect(ex).to include_elixir_syntax('elixirDocSigilDelimiter', 'S"""')
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
end
it 'doc with sigil_S triple single-quoted multiline content' do
ex = <<~'EOF'
@doc ~S'''
foo
'''
EOF
expect(ex).to include_elixir_syntax('elixirVariable', 'doc')
expect(ex).to include_elixir_syntax('elixirDocSigilDelimiter', "S'''")
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
end
it 'doc with sigil_S triple single-quoted multiline content with parentheses' do
ex = <<~'EOF'
@doc(~S'''
foo
''')
EOF
expect(ex).to include_elixir_syntax('elixirVariable', 'doc')
expect(ex).to include_elixir_syntax('elixirDocSigilDelimiter', "S'''")
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
end
it 'doc with triple single-quoted multiline content is not a doc string' do
ex = <<~'EOF'
@doc '''
foo
'''
EOF
expect(ex).not_to include_elixir_syntax('elixirDocString', 'foo')
end
it 'doc with multiline escaped' do
ex = <<~'EOF'
@doc """
foo
```
@xxx \"""
bar
\"""
```
baz
"""
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
expect(ex).to include_elixir_syntax('elixirDocString', 'bar')
expect(ex).to include_elixir_syntax('elixirDocString', 'baz')
end
it 'doc skip interpolation' do
ex = <<~'EOF'
@doc """
foo #{bar}
"""
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'foo')
expect(ex).to include_elixir_syntax('elixirDocStringDelimiter', '"""')
expect(ex).to include_elixir_syntax('elixirInterpolation', 'bar')
end
it 'doc with doctest' do
ex = <<~'EOF'
@doc """
doctest
iex> Enum.map [1, 2, 3], fn(x) ->
...> x * 2
...> end
[2, 4, 6]
"""
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocTest', 'map')
expect(ex).to include_elixir_syntax('elixirDocTest', 'x \* 2')
expect(ex).to include_elixir_syntax('elixirDocTest', '2, 4, 6')
end
describe 'doctest without newline after' do
it 'with heredoc' do
ex = <<~'EOF'
@doc """
doctest
iex> 1 + 2
3
"""
def some_fun(x), do: x
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocTest', '1 + 2')
expect(ex).to include_elixir_syntax('elixirDefine', 'def')
end
it 'with double quote' do
ex = <<~'EOF'
@doc "
doctest
iex> \"bob\"
\"bob\"
"
def some_fun(x), do: x
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocTest', 'bob')
expect(ex).to include_elixir_syntax('elixirDefine', 'def')
end
it 'with sigil_S' do
ex = <<~'EOF'
@doc ~S(
doctest
iex> to_string("bob"\)
"bob"
)
def some_fun(x), do: x
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocTest', 'bob')
expect(ex).to include_elixir_syntax('elixirDefine', 'def')
end
it 'with sigil_s' do
ex = <<~'EOF'
@doc ~s(
doctest
iex> to_string("bob"\)
"bob"
)
def some_fun(x), do: x
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocTest', 'bob')
expect(ex).to include_elixir_syntax('elixirDefine', 'def')
end
end
it 'doc with inline code' do
ex = <<~'EOF'
@doc """
doctest with inline code `List.wrap([])`
"""
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'doctest')
expect(ex).to include_elixir_syntax('elixirDocString', 'wrap')
end
describe "use markdown for docs" do
before(:each) { VIM.command("let g:elixir_use_markdown_for_docs = 1") }
after(:each) { VIM.command("let g:elixir_use_markdown_for_docs = 0") }
it 'doc with inline code' do
ex = <<~'EOF'
@doc """
doc with inline code `List.wrap([])`
"""
EOF
expect(ex).to include_elixir_syntax('elixirDocString', 'inline')
expect(ex).to include_elixir_syntax('markdownCode', 'wrap')
end
end
end
end

61
sources_non_forked/vim-elixir/spec/syntax/embedded_elixir_spec.rb Normal file
View File

@ -0,0 +1,61 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Embedded Elixir syntax' do
it 'elixir' do
expect('<%= if true do %>').to include_eelixir_syntax('elixirKeyword', 'if')
expect('<%= if true do %>').to include_eelixir_syntax('elixirBoolean', 'true')
end
it 'expression' do
expect('<%= if true do %>').to include_eelixir_syntax('eelixirExpression', 'if')
expect('<% end %>').to include_eelixir_syntax('eelixirExpression', 'end')
end
it 'quote' do
expect('<%% def f %>').to include_eelixir_syntax('eelixirQuote', 'def')
end
it 'comment' do
expect('<%# foo bar baz %>').to include_eelixir_syntax('eelixirComment', 'foo')
end
it 'delimiters' do
expect('<% end %>').to include_eelixir_syntax('eelixirDelimiter', '<%')
expect('<% end %>').to include_eelixir_syntax('eelixirDelimiter', '%>')
end
end
describe 'Embedded Live Elixir syntax' do
it 'elixir' do
expect('<%= if true do %>').to include_leelixir_syntax('elixirKeyword', 'if')
expect('<%= if true do %>').to include_leelixir_syntax('elixirBoolean', 'true')
end
it 'expression' do
expect('<%= if true do %>').to include_leelixir_syntax('eelixirExpression', 'if')
expect('<% end %>').to include_leelixir_syntax('eelixirExpression', 'end')
end
it 'quote' do
expect('<%% def f %>').to include_leelixir_syntax('eelixirQuote', 'def')
end
it 'comment' do
expect('<%# foo bar baz %>').to include_leelixir_syntax('eelixirComment', 'foo')
end
it 'delimiters' do
expect('<% end %>').to include_leelixir_syntax('eelixirDelimiter', '<%')
expect('<% end %>').to include_leelixir_syntax('eelixirDelimiter', '%>')
end
end
describe 'Embedded Surface syntax' do
it 'elixir' do
expect('{{ @foo }}').to include_surface_syntax('elixirVariable', 'foo')
expect('{{ @foo }}').to include_surface_syntax('surfaceDelimiter', '{{')
expect('{{ @foo }}').to include_surface_syntax('surfaceDelimiter', '}}')
end
end

174
sources_non_forked/vim-elixir/spec/syntax/exunit_spec.rb Normal file
View File

@ -0,0 +1,174 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'ExUnit syntax' do
it 'test macro' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'test')
test 'that stuff works' do
assert true
end
EOF
end
it 'describe macro' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'describe')
describe 'some_function/1' do
test 'that stuff works' do
assert true
end
end
EOF
end
it 'setup macro' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'setup')
setup do
IO.puts "hi mom"
end
test 'that stuff works' do
assert true
end
EOF
end
it 'setup_all macro' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'setup_all')
setup_all do
IO.puts "hi mom"
end
test 'that stuff works' do
assert true
end
EOF
end
it 'on_exit macro' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'on_exit')
setup_all do
IO.puts "hi mom"
on_exit fn() ->
do_something
end
end
test 'that stuff works' do
assert true
end
EOF
end
it 'assert' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'assert')
test 'that stuff works' do
assert true
end
EOF
end
it 'assert_in_delta' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'assert_in_delta')
test 'that stuff works' do
assert_in_delta true
end
EOF
end
it 'assert_raise' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'assert_raise')
test 'that stuff works' do
assert_raise true
end
EOF
end
it 'assert_receive' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'assert_receive')
test 'that stuff works' do
assert_receive true
end
EOF
end
it 'assert_received' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'assert_received')
test 'that stuff works' do
assert_received true
end
EOF
end
it 'catch_error' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'catch_error')
test 'that stuff works' do
catch_error true
end
EOF
end
it 'catch_exit' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'catch_exit')
test 'that stuff works' do
catch_exit true
end
EOF
end
it 'catch_throw' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'catch_throw')
test 'that stuff works' do
catch_throw true
end
EOF
end
it 'flunk' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'flunk')
test 'that stuff works' do
flunk true
end
EOF
end
it 'refute' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'refute')
test 'that stuff works' do
refute true
end
EOF
end
it 'refute_in_delta' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'refute_in_delta')
test 'that stuff works' do
refute_in_delta true
end
EOF
end
it 'refute_receive' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'refute_receive')
test 'that stuff works' do
refute_receive true
end
EOF
end
it 'refute_received' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitAssert', 'refute_received')
test 'that stuff works' do
refute_received true
end
EOF
end
it 'doctest' do
expect(<<~EOF).to include_elixir_syntax('elixirExUnitMacro', 'doctest')
module MyTest do
doctest MyModule
end
EOF
end
end

20
sources_non_forked/vim-elixir/spec/syntax/function_spec.rb Normal file
View File

@ -0,0 +1,20 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'function syntax' do
it 'doesnt treat underscored functions like unsued variables' do
expect(<<~EOF).to include_elixir_syntax('elixirId', '__ensure_defimpl__')
defp derive(protocol, for, struct, opts, env) do
# ... code ...
__ensure_defimpl__(protocol, for, env)
EOF
expect(<<~EOF).not_to include_elixir_syntax('elixirUnusedVariable', '__ensure_defimpl__')
defp derive(protocol, for, struct, opts, env) do
# ... code ...
__ensure_defimpl__(protocol, for, env)
EOF
end
end

17
sources_non_forked/vim-elixir/spec/syntax/guard_spec.rb Normal file
View File

@ -0,0 +1,17 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'defguard syntax' do
it 'defines `defguard` keyword as elixirGuard' do
expect(<<~EOF).to include_elixir_syntax('elixirGuard', 'defguard')
defguard some_guard(x) when is_integer(x)
EOF
end
it 'defines `defguardp` keyword as elixirPrivateGuard' do
expect(<<~EOF).to include_elixir_syntax('elixirPrivateGuard', 'defguardp')
defguardp some_private_guard(x) when is_integer(x)
EOF
end
end

19
sources_non_forked/vim-elixir/spec/syntax/kernel_function_spec.rb Normal file
View File

@ -0,0 +1,19 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Kernel function syntax' do
it 'kernel function used as an atom key in a keyword list outside of a block' do
expect(<<~EOF).not_to include_elixir_syntax('elixirKeyword', 'length')
do
plug Plug.Parsers, length: 400_000_000
end
EOF
end
it 'kernel function used as an atom key in a keyword list contained in a block' do
expect(<<~EOF).not_to include_elixir_syntax('elixirKeyword', 'length')
plug Plug.Parsers, length: 400_000_000
EOF
end
end

27
sources_non_forked/vim-elixir/spec/syntax/keyword_spec.rb Normal file
View File

@ -0,0 +1,27 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Keyword syntax' do
it 'for used as keyword' do
expect(<<~EOF).to include_elixir_syntax('elixirKeyword', 'for')
for v <- [1, 3, 3]
EOF
end
it 'case used as keyword' do
expect(<<~EOF).to include_elixir_syntax('elixirKeyword', 'case')
case true do
EOF
end
it 'raise used as keyword' do
expect(<<~EOF).to include_elixir_syntax('elixirKeyword', 'raise')
raise "oops"
EOF
expect(<<~EOF).to include_elixir_syntax('elixirKeyword', 'raise')
raise ArgumentError, message: "invalid argument foo"
EOF
end
end

40
sources_non_forked/vim-elixir/spec/syntax/list_spec.rb Normal file
View File

@ -0,0 +1,40 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'List syntax' do
it 'should properly handle "\\\\" inside' do
syntax = <<~EOF
'"\\\\'
var = 1
EOF
expect(syntax).to include_elixir_syntax('elixirId', 'var')
expect(syntax).not_to include_elixir_syntax('elixirString', 'var')
end
it 'recognizes lists' do
syntax = <<~EOF
[
:hello,
:world
]
EOF
expect(syntax).to include_elixir_syntax('elixirListDelimiter', '[')
expect(syntax).to include_elixir_syntax('elixirList', ':hello')
expect(syntax).to include_elixir_syntax('elixirListDelimiter', ']')
end
it 'recognizes lists inside functions' do
syntax = <<~EOF
def hello_world do
[
:hello,
:world
]
end
EOF
expect(syntax).to include_elixir_syntax('elixirListDelimiter', '[')
expect(syntax).to include_elixir_syntax('elixirList', ':hello')
expect(syntax).to include_elixir_syntax('elixirListDelimiter', ']')
end
end

14
sources_non_forked/vim-elixir/spec/syntax/map_spec.rb Normal file
View File

@ -0,0 +1,14 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Map syntax' do
it 'maps' do
str = %q(%{name: "one"})
expect(str).to include_elixir_syntax('elixirMapDelimiter', '%')
expect(str).to include_elixir_syntax('elixirMapDelimiter', '{')
expect(str).to include_elixir_syntax('elixirAtom', 'name:')
expect(str).to include_elixir_syntax('elixirMap', 'name:')
expect(str).to include_elixir_syntax('elixirMapDelimiter', '}')
end
end

17
sources_non_forked/vim-elixir/spec/syntax/module_function_spec.rb Normal file
View File

@ -0,0 +1,17 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Module function syntax' do
it 'for used as module function' do
expect(<<~EOF).to include_elixir_syntax('elixirId', 'for')
OverridesDefault.for
EOF
end
it 'case used as module function' do
expect(<<~EOF).to include_elixir_syntax('elixirId', 'case')
OverridesDefault.case
EOF
end
end

45
sources_non_forked/vim-elixir/spec/syntax/numbers_spec.rb Normal file
View File

@ -0,0 +1,45 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Numbers syntax' do
describe 'decimal' do
it 'positive is colorized' do
expect('123').to include_elixir_syntax('elixirNumber', '123')
end
it 'negative is colorized' do
expect('-123').to include_elixir_syntax('elixirNumber', '123')
end
end
describe 'hexadecimal' do
it 'positive is colorized' do
expect('0xdeadbeaf').to include_elixir_syntax('elixirNumber', '0xdeadbeaf')
end
it 'negative is colorized' do
expect('-0xdeadbeaf').to include_elixir_syntax('elixirNumber', '0xdeadbeaf')
end
end
describe 'octal' do
it 'positive is colorized' do
expect('0o777').to include_elixir_syntax('elixirNumber', '0o777')
end
it 'negative is colorized' do
expect('-0o777').to include_elixir_syntax('elixirNumber', '0o777')
end
end
describe 'binary' do
it 'positive is colorized' do
expect('0b1011').to include_elixir_syntax('elixirNumber', '0b1011')
end
it 'negative is colorized' do
expect('-0b1011').to include_elixir_syntax('elixirNumber', '0b1011')
end
end
end

31
sources_non_forked/vim-elixir/spec/syntax/operator_spec.rb Normal file
View File

@ -0,0 +1,31 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Operators' do
it 'default argument' do
expect(<<~'EOF').to include_elixir_syntax('elixirOperator', '\\')
def foo(bar \\ :baz)
EOF
expect(<<~EOF).to include_elixir_syntax('elixirOperator', '\/')
def foo(bar // :baz)
EOF
end
it 'in' do
expect(<<~EOF).to include_elixir_syntax('elixirOperator', 'in')
'x' in ['x']
EOF
expect(<<~EOF).not_to include_elixir_syntax('elixirOperator', 'in')
:queue.in x, 5
EOF
end
it 'does not highlight operators inside of elixirIds' do
expect(<<~EOF).not_to include_elixir_syntax('elixirOperator', 'in')
incoming
EOF
end
end

12
sources_non_forked/vim-elixir/spec/syntax/records_spec.rb Normal file
View File

@ -0,0 +1,12 @@
# frozen_string_literal: true
# encoding: utf-8
require 'spec_helper'
describe 'Record syntax' do
it 'private record symbol' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', ':user')
defrecordp :user, name: "José", age: 25
EOF
end
end

146
sources_non_forked/vim-elixir/spec/syntax/sigil_spec.rb Normal file
View File

@ -0,0 +1,146 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Sigil syntax' do
it 'as function argument' do
expect('def f(~s(")), do: true').to include_elixir_syntax('elixirSigilDelimiter', '\~s(')
expect('def f(~s(")), do: true').to include_elixir_syntax('elixirSigil', '"')
expect("def f(~s(')), do: true").to include_elixir_syntax('elixirSigil', "'")
expect('def f(~s(")), do: true').not_to include_elixir_syntax('elixirSigilDelimiter', '"')
end
it 'as function argument multiline content' do
ex = <<~'EOF'
f(
~S"""
foo
""",
bar
)
EOF
expect(ex).to include_elixir_syntax('elixirSigilDelimiter', 'S"""')
expect(ex).to include_elixir_syntax('elixirSigil', 'foo')
end
describe 'upper case' do
it 'string' do
expect('~S(string)').to include_elixir_syntax('elixirSigilDelimiter', 'S')
expect('~S(string)').to include_elixir_syntax('elixirSigil', 'string')
end
it 'character list' do
expect('~C(charlist)').to include_elixir_syntax('elixirSigilDelimiter', 'C')
expect('~C(charlist)').to include_elixir_syntax('elixirSigil', 'charlist')
end
it 'regular expression' do
expect('~R(regex)').to include_elixir_syntax('elixirSigilDelimiter', 'R')
expect('~R(regex)').to include_elixir_syntax('elixirSigil', 'regex')
end
it 'list of words' do
expect('~W(list of words)').to include_elixir_syntax('elixirSigilDelimiter', 'W')
expect('~W(list of words)').to include_elixir_syntax('elixirSigil', 'list')
end
it 'delimited with parenthesis' do
expect('~S(foo bar)').to include_elixir_syntax('elixirSigilDelimiter', '(')
expect('~S(foo bar)').to include_elixir_syntax('elixirSigilDelimiter', ')')
end
it 'delimited with braces' do
expect('~S{foo bar}').to include_elixir_syntax('elixirSigilDelimiter', '{')
expect('~S{foo bar}').to include_elixir_syntax('elixirSigilDelimiter', '}')
end
it 'delimited with brackets' do
expect('~S[foo bar]').to include_elixir_syntax('elixirSigilDelimiter', '[')
expect('~S[foo bar]').to include_elixir_syntax('elixirSigilDelimiter', ']')
end
it 'escapes double quotes unless only preceded by whitespace' do
expect(<<~EOF).to include_elixir_syntax('elixirSigilDelimiter', %q(^\s*\zs"""))
~r"""
foo """
"""
EOF
end
it 'escapes single quotes unless only preceded by whitespace' do
expect(<<~EOF).to include_elixir_syntax('elixirSigilDelimiter', %q(^\s*\zs'''))
~r'''
foo '''
'''
EOF
end
it 'without escapes' do
expect('~S(foo \n bar)').not_to include_elixir_syntax('elixirRegexEscape', '\\')
end
it 'without interpolation' do
expect('~S(foo #{bar})').not_to include_elixir_syntax('elixirInterpolation', 'bar')
end
it 'without escaped parenthesis' do
expect('~S(\( )').not_to include_elixir_syntax('elixirRegexEscapePunctuation', '( ')
end
it 'Live EEx' do
expect('~L"""liveview template"""').to include_elixir_syntax('elixirSigilDelimiter', '"""')
end
it 'Surface EEx' do
expect('~H"""surface template"""').to include_elixir_syntax('elixirSigilDelimiter', '"""')
end
it 'EEx' do
expect('~E"""Phoenix.HTML template"""').to include_elixir_syntax('elixirSigilDelimiter', '"""')
expect('~e"""Phoenix.HTML template"""').to include_elixir_syntax('elixirSigilDelimiter', '"""')
end
end
describe 'lower case' do
it 'string' do
expect('~s(string)').to include_elixir_syntax('elixirSigilDelimiter', 's')
expect('~s(string)').to include_elixir_syntax('elixirSigil', 'string')
end
it 'character list' do
expect('~c(charlist)').to include_elixir_syntax('elixirSigilDelimiter', 'c')
expect('~c(charlist)').to include_elixir_syntax('elixirSigil', 'charlist')
end
it 'regular expression' do
expect('~r(regex)').to include_elixir_syntax('elixirSigilDelimiter', 'r')
expect('~r(regex)').to include_elixir_syntax('elixirSigil', 'regex')
end
it 'list of words' do
expect('~w(list of words)').to include_elixir_syntax('elixirSigilDelimiter', 'w')
expect('~w(list of words)').to include_elixir_syntax('elixirSigil', 'list')
end
it 'with escapes' do
expect('~s(foo \n bar)').to include_elixir_syntax('elixirRegexEscapePunctuation', '\\')
end
it 'with interpolation' do
expect('~s(foo #{bar})').to include_elixir_syntax('elixirInterpolation', 'bar')
end
it 'with escaped parenthesis' do
expect('~s(\( )').to include_elixir_syntax('elixirRegexEscapePunctuation', '( ')
end
it 'interpolation with slashes' do
expect('~s/foo #{bar}/').to include_elixir_syntax('elixirInterpolation', 'bar')
end
it 'escapes with slashes' do
expect('~s/foo \n bar/').to include_elixir_syntax('elixirRegexEscapePunctuation', '\\')
end
end
end

109
sources_non_forked/vim-elixir/spec/syntax/strings_spec.rb Normal file
View File

@ -0,0 +1,109 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'String syntax' do
describe 'binary' do
it 'double quoted string' do
expect('foo "test"').to include_elixir_syntax('elixirString', 'test')
end
it 'double quoted string with escaped quote' do
expect('"this \"test is all one string"').to include_elixir_syntax('elixirString', 'test')
end
it 'charlist with escaped quote' do
expect(<<-'EOF').to include_elixir_syntax('elixirCharList', 'test')
'this \'test is all one charlist'
EOF
end
it 'interpolation in string' do
expect('do_something "foo #{test}"').to include_elixir_syntax('elixirInterpolation', 'test')
end
end
describe 'heredoc' do
it 'heredoc must be string' do
ex = <<~EOF
def function do
"""
foo "test"
"""
end
EOF
expect(ex).to include_elixir_syntax('elixirString', 'foo')
expect(ex).to include_elixir_syntax('elixirString', 'test')
end
it 'interpolation in string in heredoc' do
expect(<<~'EOF').to include_elixir_syntax('elixirInterpolation', '#{')
def function do
"""
foo "#{test}"
"""
end
EOF
end
it 'interpolation in heredoc' do
expect(<<~'EOF').to include_elixir_syntax('elixirInterpolation', '#{')
def function do
"""
foo #{test}
"""
end
EOF
end
it 'correctly terminates heredocs with no spaces at the start of the line' do
expect(<<~'EOF'.gsub(/^\s+/, '')).to include_elixir_syntax('elixirAtom', ':bar')
"""
foo
"""
:bar
EOF
expect(<<~'EOF'.gsub(/^\s+/, '')).to include_elixir_syntax('elixirAtom', ':bar')
'''
foo
'''
:bar
EOF
end
it 'interpolation with a tuple' do
str = <<~'EOF'
"Failed sending tasks #{inspect {:unexpected_status_code, s}}"
EOF
expect(str).not_to include_elixir_syntax('elixirInterpolationDelimiter', '}}"$')
expect(str).to include_elixir_syntax('elixirInterpolationDelimiter', '}"$')
end
it 'interpolation with a tuple' do
str = <<~'EOF'
"Failed sending tasks #{inspect %{unexpected_status_code: s}}"
EOF
expect(str).not_to include_elixir_syntax('elixirInterpolationDelimiter', '}}"$')
expect(str).to include_elixir_syntax('elixirInterpolationDelimiter', '}"$')
end
it 'interpolation with a struct' do
str = <<~'EOF'
"Failed sending tasks #{inspect %ResponseStruct{unexpected_status_code: s}}"
EOF
expect(str).not_to include_elixir_syntax('elixirInterpolationDelimiter', '}}"$')
expect(str).to include_elixir_syntax('elixirInterpolationDelimiter', '}"$')
end
it 'strings with embedded braces' do
str = <<~EOF
x = [
{:text, "asd {"},
{:text, "qwe"},
]
EOF
expect(str).to include_elixir_syntax('elixirString', '{"}')
end
end
end

64
sources_non_forked/vim-elixir/spec/syntax/struct_spec.rb Normal file
View File

@ -0,0 +1,64 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Struct syntax' do
it 'without defaults' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', ':name')
defstruct [:name, :age]
EOF
end
it 'with defaults' do
expect(<<~EOF).to include_elixir_syntax('elixirAtom', 'name:')
defstruct name: "john", age: 27
EOF
end
it 'structs' do
str = %q(%MyStruct{name: "one"})
expect(str).to include_elixir_syntax('elixirStructDelimiter', '%')
expect(str).to include_elixir_syntax('elixirStruct', '%')
expect(str).to include_elixir_syntax('elixirAlias', 'MyStruct')
expect(str).to include_elixir_syntax('elixirStruct', 'MyStruct')
expect(str).to include_elixir_syntax('elixirStructDelimiter', '{')
expect(str).to include_elixir_syntax('elixirStruct', '{')
expect(str).to include_elixir_syntax('elixirAtom', 'name:')
expect(str).to include_elixir_syntax('elixirStruct', 'name:')
expect(str).to include_elixir_syntax('elixirStructDelimiter', '}')
end
it 'properly closes strings in structs' do
str = <<~'EOF'
%MyStruct{url: "http://127.0.0.1:#{port}"} # anchor
# this should not be a string still
EOF
expect(str).to include_elixir_syntax('elixirStruct', '{url')
expect(str).to include_elixir_syntax('elixirStringDelimiter', '"http')
expect(str).to include_elixir_syntax('elixirStruct', '"http')
expect(str).to include_elixir_syntax('elixirInterpolationDelimiter', '#{')
expect(str).to include_elixir_syntax('elixirStruct', '#{')
expect(str).to include_elixir_syntax('elixirInterpolationDelimiter', '}"}')
expect(str).to include_elixir_syntax('elixirStruct', '}"}')
expect(str).not_to include_elixir_syntax('elixirStructDelimiter', '}"}')
expect(str).to include_elixir_syntax('elixirStringDelimiter', '"}')
expect(str).to include_elixir_syntax('elixirStruct', '"}')
expect(str).to include_elixir_syntax('elixirStringDelimiter', '"}')
expect(str).to include_elixir_syntax('elixirStruct', '"}')
expect(str).to include_elixir_syntax('elixirStructDelimiter', '} #')
expect(str).to include_elixir_syntax('elixirComment', '# this should not be a string still')
end
end

17
sources_non_forked/vim-elixir/spec/syntax/tuple_spec.rb Normal file
View File

@ -0,0 +1,17 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Tuple syntax' do
it 'tuples' do
str = %q({:name, "one"})
expect(str).to include_elixir_syntax('elixirTupleDelimiter', '{')
expect(str).to include_elixir_syntax('elixirTuple', '{')
expect(str).to include_elixir_syntax('elixirAtom', ':name')
expect(str).to include_elixir_syntax('elixirTuple', ':name')
expect(str).to include_elixir_syntax('elixirTupleDelimiter', '}')
end
end

75
sources_non_forked/vim-elixir/spec/syntax/variable_spec.rb Normal file
View File

@ -0,0 +1,75 @@
# frozen_string_literal: true
require 'spec_helper'
describe 'Variable syntax' do
it 'unused' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_from')
def handle_call(:pop, _from, [h|stack]) do
{ :reply, h, stack }
end
EOF
end
it 'unused in function body' do
expect(<<~EOF).not_to include_elixir_syntax('elixirUnusedVariable', '_from')
def handle_call(:pop)
Hello._from
end
EOF
end
it 'unused, multiple lines' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_from')
def handle_call(:pop,
_from,
[h|stack]) do
{ :reply, h, stack }
end
EOF
end
it 'unused, single char' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_')
def call(:pop, _, [h|stack]) do
{ :reply, h, stack }
end
EOF
end
it 'unused in pattern_match' do
str = <<~EOF
def sign_in(conn, %{
"data" => %{
"type" => "doctor",
"attributes" => %{
"institution_code" => institution_code,
"password" => password,
"email_or_phone" => email_or_phone}}}, _user, _claims) do
:ok
end
EOF
expect(str).to include_elixir_syntax('elixirUnusedVariable', '_user')
expect(str).to include_elixir_syntax('elixirUnusedVariable', '_claims')
end
it 'unused, in anonymous function, inline' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_unused')
fun = fn _unused -> false end
EOF
end
it 'unused, in anonymous function, multiple lines' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_unused')
fun = fn
([], _unused) -> true
end
EOF
end
it 'unused, in pattern matching' do
expect(<<~EOF).to include_elixir_syntax('elixirUnusedVariable', '_unused')
_unused = false
EOF
end
end

80
sources_non_forked/vim-elixir/syntax/eelixir.vim Normal file
View File

@ -0,0 +1,80 @@
if exists("b:current_syntax")
finish
endif
let s:cpo_save = &cpo
set cpo&vim
if !exists("main_syntax")
let main_syntax = 'eelixir'
endif
if !exists("g:eelixir_default_subtype")
let g:eelixir_default_subtype = "html"
endif
if !exists("b:eelixir_subtype")
let s:lines = getline(1)."\n".getline(2)."\n".getline(3)."\n".getline(4)."\n".getline(5)."\n".getline("$")
let b:eelixir_subtype = matchstr(s:lines,'eelixir_subtype=\zs\w\+')
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^eex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^heex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^leex\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(&filetype,'^sface\.\zs\w\+')
endif
if b:eelixir_subtype == ''
let b:eelixir_subtype = matchstr(substitute(expand("%:t"),'\c\%(\.eex\|\.heex\|\.leex\|\.sface\|\.eelixir\)\+$','',''),'\.\zs\w\+$')
endif
if b:eelixir_subtype == 'ex'
let b:eelixir_subtype = 'elixir'
elseif b:eelixir_subtype == 'exs'
let b:eelixir_subtype = 'elixir'
elseif b:eelixir_subtype == 'yml'
let b:eelixir_subtype = 'yaml'
elseif b:eelixir_subtype == 'js'
let b:eelixir_subtype = 'javascript'
elseif b:eelixir_subtype == 'txt'
" Conventional; not a real file type
let b:eelixir_subtype = 'text'
elseif b:eelixir_subtype == ''
let b:eelixir_subtype = g:eelixir_default_subtype
endif
endif
if exists("b:eelixir_subtype") && b:eelixir_subtype != ''
exe "runtime! syntax/".b:eelixir_subtype.".vim"
unlet! b:current_syntax
endif
syn include @elixirTop syntax/elixir.vim
syn cluster eelixirRegions contains=eelixirBlock,surfaceExpression,eelixirExpression,eelixirComment
exe 'syn region eelixirExpression matchgroup=eelixirDelimiter start="<%" end="%\@<!%>" contains=@elixirTop containedin=ALLBUT,@eelixirRegions keepend'
exe 'syn region eelixirExpression matchgroup=eelixirDelimiter start="<%=" end="%\@<!%>" contains=@elixirTop containedin=ALLBUT,@eelixirRegions keepend'
exe 'syn region surfaceExpression matchgroup=surfaceDelimiter start="{{" end="}}" contains=@elixirTop containedin=ALLBUT,@eelixirRegions keepend'
exe 'syn region surfaceExpression matchgroup=surfaceDelimiter start="{" end="}" contains=@elixirTop containedin=ALLBUT,@eelixirRegions keepend'
exe 'syn region surfaceExpression matchgroup=surfaceDelimiter start="{" end="}" skip="#{[^}]*}" contains=@elixirTop containedin=htmlValue keepend'
exe 'syn region eelixirQuote matchgroup=eelixirDelimiter start="<%%" end="%\@<!%>" contains=@elixirTop containedin=ALLBUT,@eelixirRegions keepend'
exe 'syn region eelixirComment matchgroup=eelixirDelimiter start="<%#" end="%\@<!%>" contains=elixirTodo,@Spell containedin=ALLBUT,@eelixirRegions keepend'
" Define the default highlighting.
hi def link eelixirDelimiter PreProc
hi def link surfaceDelimiter PreProc
hi def link eelixirComment Comment
let b:current_syntax = 'eelixir'
if main_syntax == 'eelixir'
unlet main_syntax
endif
let &cpo = s:cpo_save
unlet s:cpo_save

254
sources_non_forked/vim-elixir/syntax/elixir.vim Normal file
View File

@ -0,0 +1,254 @@
if !exists("main_syntax")
if exists("b:current_syntax")
finish
endif
let main_syntax = "elixir"
endif
let s:cpo_save = &cpo
set cpo&vim
syn cluster elixirNotTop contains=@elixirRegexSpecial,@elixirStringContained,@elixirDeclaration,elixirTodo,elixirArguments,elixirBlockDefinition,elixirUnusedVariable,elixirStructDelimiter,elixirListDelimiter
syn cluster elixirRegexSpecial contains=elixirRegexEscape,elixirRegexCharClass,elixirRegexQuantifier,elixirRegexEscapePunctuation
syn cluster elixirStringContained contains=elixirInterpolation,elixirRegexEscape,elixirRegexCharClass
syn cluster elixirDeclaration contains=elixirFunctionDeclaration,elixirPrivateFunctionDeclaration,elixirModuleDeclaration,elixirProtocolDeclaration,elixirImplDeclaration,elixirRecordDeclaration,elixirPrivateRecordDeclaration,elixirMacroDeclaration,elixirPrivateMacroDeclaration,elixirDelegateDeclaration,elixirOverridableDeclaration,elixirExceptionDeclaration,elixirCallbackDeclaration,elixirStructDeclaration
syn match elixirComment '#.*' contains=elixirTodo,@Spell
syn keyword elixirTodo FIXME NOTE TODO OPTIMIZE XXX HACK contained
syn match elixirId '\<[_a-zA-Z]\w*[!?]\?\>' contains=elixirUnusedVariable
syn match elixirKeyword '\(\.\)\@<!\<\(for\|case\|when\|with\|cond\|if\|unless\|try\|receive\|after\|raise\|rescue\|catch\|else\|quote\|unquote\|super\|unquote_splicing\)\>:\@!'
syn keyword elixirInclude import require alias use
syn keyword elixirSelf self
syn match elixirUnusedVariable contained '\%(\.\)\@<!\<_\w*\>\%((\)\@!'
syn match elixirOperator '\v\.@<!<%(and|or|in|not)>'
syn match elixirOperator '!==\|!=\|!'
syn match elixirOperator '=\~\|===\|==\|='
syn match elixirOperator '<<<\|<<\|<=\|<-\|<'
syn match elixirOperator '>>>\|>>\|>=\|>'
syn match elixirOperator '->\|--\|-'
syn match elixirOperator '++\|+'
syn match elixirOperator '&&&\|&&\|&'
syn match elixirOperator '|||\|||\||>\||'
syn match elixirOperator '\.\.\|\.'
syn match elixirOperator "\^\^\^\|\^"
syn match elixirOperator '\\\\\|::\|\*\|/\|\~\~\~\|@'
syn match elixirOperator '\~>\|\~>>\|<\~\|<<\~\|<\~>'
syn match elixirAlias '\([a-z]\)\@<![A-Z]\w*\%(\.[A-Z]\w*\)*'
syn match elixirAtom '\(:\)\@<!:\%([a-zA-Z_*]\w*\%([?!]\|=[>=]\@!\)\?\|<>\|===\?\|>=\?\|<=\?\)'
syn match elixirAtom '\(:\)\@<!:\%(<=>\|&&\?\|%\(()\|\[\]\|{}\)\|++\?\|--\?\|||\?\|!\|//\|[%&`/|]\)'
syn match elixirAtom "\%([a-zA-Z_]\w*[?!]\?\):\(:\)\@!"
syn keyword elixirBoolean true false nil
syn match elixirVariable '@[a-z]\w*'
syn match elixirVariable '&\d\+'
syn keyword elixirPseudoVariable __FILE__ __DIR__ __MODULE__ __ENV__ __CALLER__ __STACKTRACE__
syn match elixirNumber '\<-\?\d\(_\?\d\)*\(\.[^[:space:][:digit:]]\@!\(_\?\d\)*\)\?\([eE][-+]\?\d\(_\?\d\)*\)\?\>'
syn match elixirNumber '\<-\?0[xX][0-9A-Fa-f]\+\>'
syn match elixirNumber '\<-\?0[oO][0-7]\+\>'
syn match elixirNumber '\<-\?0[bB][01]\+\>'
syn match elixirRegexEscape "\\\\\|\\[aAbBcdDefGhHnrsStvVwW]\|\\\d\{3}\|\\x[0-9a-fA-F]\{2}" contained
syn match elixirRegexEscapePunctuation "?\|\\.\|*\|\\\[\|\\\]\|+\|\\^\|\\\$\|\\|\|\\(\|\\)\|\\{\|\\}" contained
syn match elixirRegexQuantifier "[*?+][?+]\=" contained display
syn match elixirRegexQuantifier "{\d\+\%(,\d*\)\=}?\=" contained display
syn match elixirRegexCharClass "\[:\(alnum\|alpha\|ascii\|blank\|cntrl\|digit\|graph\|lower\|print\|punct\|space\|upper\|word\|xdigit\):\]" contained display
syn region elixirRegex matchgroup=elixirRegexDelimiter start="%r/" end="/[uiomxfr]*" skip="\\\\" contains=@elixirRegexSpecial
syn region elixirTuple matchgroup=elixirTupleDelimiter start="\(\w\|#\)\@<!{" end="}" contains=ALLBUT,@elixirNotTop fold
syn match elixirListDelimiter '\[' contained containedin=elixirList
syn region elixirList matchgroup=elixirListDelimiter start='\[' end='\]' contains=ALLBUT,@elixirNotTop fold
syn match elixirStructDelimiter '{' contained containedin=elixirStruct
syn region elixirStruct matchgroup=elixirStructDelimiter start="%\(\w\+{\)\@=" end="}" contains=ALLBUT,@elixirNotTop fold
syn region elixirMap matchgroup=elixirMapDelimiter start="%{" end="}" contains=ALLBUT,@elixirNotTop fold
syn region elixirCharList matchgroup=elixirCharListDelimiter start=+\z('\)+ end=+\z1+ skip=+\\\\\|\\\z1+ contains=@Spell,@elixirStringContained
syn region elixirString matchgroup=elixirStringDelimiter start=+\z("\)+ end=+\z1+ skip=+\\\\\|\\\z1+ contains=@Spell,@elixirStringContained
syn region elixirString matchgroup=elixirStringDelimiter start=+\z('''\)+ end=+^\s*\z1+ contains=@Spell,@elixirStringContained
syn region elixirString matchgroup=elixirStringDelimiter start=+\z("""\)+ end=+^\s*\z1+ contains=@Spell,@elixirStringContained
syn region elixirInterpolation matchgroup=elixirInterpolationDelimiter start="#{" end="}" contained contains=ALLBUT,elixirComment,@elixirNotTop
syn match elixirAtomInterpolated ':\("\)\@=' contains=elixirString
syn match elixirString "\(\w\)\@<!?\%(\\\(x\d{1,2}\|\h{1,2}\h\@!\>\|0[0-7]{0,2}[0-7]\@!\>\|[^x0MC]\)\|(\\[MC]-)+\w\|[^\s\\]\)"
syn region elixirBlock matchgroup=elixirBlockDefinition start="\<do\>:\@!" end="\<end\>" contains=ALLBUT,@elixirNotTop fold
syn region elixirAnonymousFunction matchgroup=elixirBlockDefinition start="\<fn\>" end="\<end\>" contains=ALLBUT,@elixirNotTop fold
syn region elixirArguments start="(" end=")" contained contains=elixirOperator,elixirAtom,elixirPseudoVariable,elixirAlias,elixirBoolean,elixirVariable,elixirUnusedVariable,elixirNumber,elixirDocString,elixirAtomInterpolated,elixirRegex,elixirString,elixirStringDelimiter,elixirRegexDelimiter,elixirInterpolationDelimiter,elixirSigil,elixirAnonymousFunction,elixirComment,elixirCharList,elixirCharListDelimiter
syn match elixirDelimEscape "\\[(<{\[)>}\]/\"'|]" transparent display contained contains=NONE
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\u\z(/\|\"\|'\||\)" end="\z1" skip="\\\\\|\\\z1" contains=elixirDelimEscape fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\u{" end="}" skip="\\\\\|\\}" contains=elixirDelimEscape fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\u<" end=">" skip="\\\\\|\\>" contains=elixirDelimEscape fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\u\[" end="\]" skip="\\\\\|\\\]" contains=elixirDelimEscape fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\u(" end=")" skip="\\\\\|\\)" contains=elixirDelimEscape fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l\z(/\|\"\|'\||\)" end="\z1" skip="\\\\\|\\\z1" fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l{" end="}" skip="\\\\\|\\}" contains=@elixirStringContained,elixirRegexEscapePunctuation fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l<" end=">" skip="\\\\\|\\>" contains=@elixirStringContained,elixirRegexEscapePunctuation fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l\[" end="\]" skip="\\\\\|\\\]" contains=@elixirStringContained,elixirRegexEscapePunctuation fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l(" end=")" skip="\\\\\|\\)" contains=@elixirStringContained,elixirRegexEscapePunctuation fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start="\~\l\/" end="\/" skip="\\\\\|\\\/" contains=@elixirStringContained,elixirRegexEscapePunctuation fold
" Sigils surrounded with heredoc
syn region elixirSigil matchgroup=elixirSigilDelimiter start=+\~\a\z("""\)+ end=+^\s*\z1+ skip=+\\"+ fold
syn region elixirSigil matchgroup=elixirSigilDelimiter start=+\~\a\z('''\)+ end=+^\s*\z1+ skip=+\\'+ fold
" LiveView Sigils surrounded with ~L"""
syntax include @HTML syntax/html.vim
unlet b:current_syntax
syntax region elixirLiveViewSigil matchgroup=elixirSigilDelimiter keepend start=+\~L\z("""\)+ end=+^\s*\z1+ skip=+\\"+ contains=@HTML fold
syntax region elixirSurfaceSigil matchgroup=elixirSigilDelimiter keepend start=+\~H\z("""\)+ end=+^\s*\z1+ skip=+\\"+ contains=@HTML fold
syntax region elixirSurfaceSigil matchgroup=elixirSigilDelimiter keepend start=+\~F\z("""\)+ end=+^\s*\z1+ skip=+\\"+ contains=@HTML fold
syntax region elixirPhoenixESigil matchgroup=elixirSigilDelimiter keepend start=+\~E\z("""\)+ end=+^\s*\z1+ skip=+\\"+ contains=@HTML fold
syntax region elixirPhoenixeSigil matchgroup=elixirSigilDelimiter keepend start=+\~e\z("""\)+ end=+^\s*\z1+ skip=+\\"+ contains=@HTML fold
" Documentation
if exists('g:elixir_use_markdown_for_docs') && g:elixir_use_markdown_for_docs
syn include @markdown syntax/markdown.vim
unlet b:current_syntax
syn cluster elixirDocStringContained contains=@markdown,@Spell,elixirInterpolation
else
let g:elixir_use_markdown_for_docs = 0
syn cluster elixirDocStringContained contains=elixirDocTest,elixirTodo,@Spell,elixirInterpolation
" doctests
syn region elixirDocTest start="^\s*\%(iex\|\.\.\.\)\%((\d*)\)\?>\s" end="^\s*$" contained
endif
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start="\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]\z(/\|\"\|'\||\)" end="\z1" skip="\\\\\|\\\z1" contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start="\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]{" end="}" skip="\\\\\|\\}" contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start="\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]<" end=">" skip="\\\\\|\\>" contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start="\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]\[" end="\]" skip="\\\\\|\\\]" contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start="\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss](" end=")" skip="\\\\\|\\)" contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocStringDelimiter start=+\%(@\w*doc\(\s\|(\)\+\)\@<=\z("\)+ end=+\z1+ skip=+\\\\\|\\\z1+ contains=@elixirDocStringContained keepend
syn region elixirDocString matchgroup=elixirDocStringDelimiter start=+\%(@\w*doc\(\s\|(\)\+\)\@<=\z("""\)+ end=+^\s*\z1+ contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start=+\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]\z('''\)+ end=+^\s*\z1+ contains=@elixirDocStringContained fold keepend
syn region elixirDocString matchgroup=elixirDocSigilDelimiter start=+\%(@\w*doc\(\s\|(\)\+\)\@<=\~[Ss]\z("""\)+ end=+^\s*\z1+ contains=@elixirDocStringContained fold keepend
" Defines
syn match elixirDefine '\<def\>\(:\)\@!' nextgroup=elixirFunctionDeclaration skipwhite skipnl
syn match elixirPrivateDefine '\<defp\>\(:\)\@!' nextgroup=elixirPrivateFunctionDeclaration skipwhite skipnl
syn match elixirNumericalDefine '\<defn\>\(:\)\@!' nextgroup=elixirFunctionDeclaration skipwhite skipnl
syn match elixirGuard '\<defguard\>\(:\)\@!' nextgroup=elixirFunctionDeclaration skipwhite skipnl
syn match elixirPrivateGuard '\<defguardp\>\(:\)\@!' nextgroup=elixirPrivateFunctionDeclaration skipwhite skipnl
syn match elixirModuleDefine '\<defmodule\>\(:\)\@!' nextgroup=elixirModuleDeclaration skipwhite skipnl
syn match elixirProtocolDefine '\<defprotocol\>\(:\)\@!' nextgroup=elixirProtocolDeclaration skipwhite skipnl
syn match elixirImplDefine '\<defimpl\>\(:\)\@!' nextgroup=elixirImplDeclaration skipwhite skipnl
syn match elixirRecordDefine '\<defrecord\>\(:\)\@!' nextgroup=elixirRecordDeclaration skipwhite skipnl
syn match elixirPrivateRecordDefine '\<defrecordp\>\(:\)\@!' nextgroup=elixirPrivateRecordDeclaration skipwhite skipnl
syn match elixirMacroDefine '\<defmacro\>\(:\)\@!' nextgroup=elixirMacroDeclaration skipwhite skipnl
syn match elixirPrivateMacroDefine '\<defmacrop\>\(:\)\@!' nextgroup=elixirPrivateMacroDeclaration skipwhite skipnl
syn match elixirDelegateDefine '\<defdelegate\>\(:\)\@!' nextgroup=elixirDelegateDeclaration skipwhite skipnl
syn match elixirOverridableDefine '\<defoverridable\>\(:\)\@!' nextgroup=elixirOverridableDeclaration skipwhite skipnl
syn match elixirExceptionDefine '\<defexception\>\(:\)\@!' nextgroup=elixirExceptionDeclaration skipwhite skipnl
syn match elixirCallbackDefine '\<defcallback\>\(:\)\@!' nextgroup=elixirCallbackDeclaration skipwhite skipnl
syn match elixirStructDefine '\<defstruct\>\(:\)\@!' skipwhite skipnl
" Declarations
syn match elixirModuleDeclaration "[^[:space:];#<,()\[\]]\+" contained nextgroup=elixirBlock skipwhite skipnl
syn match elixirFunctionDeclaration "[^[:space:];#<,()\[\]]\+" contained nextgroup=elixirArguments skipwhite skipnl
syn match elixirPrivateFunctionDeclaration "[^[:space:];#<,()\[\]]\+" contained nextgroup=elixirArguments skipwhite skipnl
syn match elixirProtocolDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias skipwhite skipnl
syn match elixirImplDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias skipwhite skipnl
syn match elixirRecordDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias,elixirAtom skipwhite skipnl
syn match elixirPrivateRecordDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias,elixirAtom skipwhite skipnl
syn match elixirMacroDeclaration "[^[:space:];#<,()\[\]]\+" contained nextgroup=elixirArguments skipwhite skipnl
syn match elixirPrivateMacroDeclaration "[^[:space:];#<,()\[\]]\+" contained nextgroup=elixirArguments skipwhite skipnl
syn match elixirDelegateDeclaration "[^[:space:];#<,()\[\]]\+" contained contains=elixirFunctionDeclaration skipwhite skipnl
syn region elixirDelegateDeclaration start='\[' end='\]' contained contains=elixirFunctionDeclaration skipwhite skipnl
syn match elixirOverridableDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias,elixirAtom skipwhite skipnl
syn match elixirExceptionDeclaration "[^[:space:];#<]\+" contained contains=elixirAlias,elixirAtom skipwhite skipnl
syn match elixirCallbackDeclaration "[^[:space:];#<,()\[\]]\+" contained contains=elixirFunctionDeclaration skipwhite skipnl
" ExUnit
syn match elixirExUnitMacro "\C\(^\s*\)\@<=\<\(test\|describe\|setup\|setup_all\|on_exit\|doctest\)\>"
syn match elixirExUnitAssert "\C\(^\s*\)\@<=\<\(assert\|assert_in_delta\|assert_raise\|assert_receive\|assert_received\|catch_error\)\>"
syn match elixirExUnitAssert "\C\(^\s*\)\@<=\<\(catch_exit\|catch_throw\|flunk\|refute\|refute_in_delta\|refute_receive\|refute_received\)\>"
" syncing starts 2000 lines before top line so docstrings don't screw things up
syn sync minlines=2000
hi def link elixirBlockDefinition Define
hi def link elixirDefine Define
hi def link elixirPrivateDefine Define
hi def link elixirNumericalDefine Define
hi def link elixirGuard Define
hi def link elixirPrivateGuard Define
hi def link elixirModuleDefine Define
hi def link elixirProtocolDefine Define
hi def link elixirImplDefine Define
hi def link elixirRecordDefine Define
hi def link elixirPrivateRecordDefine Define
hi def link elixirMacroDefine Define
hi def link elixirPrivateMacroDefine Define
hi def link elixirDelegateDefine Define
hi def link elixirOverridableDefine Define
hi def link elixirExceptionDefine Define
hi def link elixirCallbackDefine Define
hi def link elixirStructDefine Define
hi def link elixirExUnitMacro Define
hi def link elixirModuleDeclaration Type
hi def link elixirPrivateFunctionDeclaration elixirFunctionDeclaration
hi def link elixirFunctionDeclaration Function
hi def link elixirPrivateMacroDeclaration elixirMacroDeclaration
hi def link elixirMacroDeclaration Macro
hi def link elixirInclude Include
hi def link elixirComment Comment
hi def link elixirTodo Todo
hi def link elixirKeyword Define
hi def link elixirExUnitAssert Keyword
hi def link elixirOperator Operator
hi def link elixirAtom Constant
hi def link elixirPseudoVariable Constant
hi def link elixirAlias Type
hi def link elixirBoolean Boolean
hi def link elixirVariable Identifier
hi def link elixirSelf Identifier
hi def link elixirUnusedVariable Comment
hi def link elixirNumber Number
hi def link elixirDocString Comment
hi def link elixirDocTest elixirKeyword
hi def link elixirAtomInterpolated elixirAtom
hi def link elixirRegex elixirString
hi def link elixirRegexEscape elixirSpecial
hi def link elixirRegexEscapePunctuation elixirSpecial
hi def link elixirRegexCharClass elixirSpecial
hi def link elixirRegexQuantifier elixirSpecial
hi def link elixirSpecial Special
hi def link elixirString String
hi def link elixirCharList String
hi def link elixirSigil String
hi def link elixirDocStringDelimiter elixirStringDelimiter
hi def link elixirDocSigilDelimiter elixirSigilDelimiter
hi def link elixirStringDelimiter Delimiter
hi def link elixirCharListDelimiter Delimiter
hi def link elixirRegexDelimiter Delimiter
hi def link elixirInterpolationDelimiter Delimiter
hi def link elixirSigilDelimiter Delimiter
hi def link elixirPrivateRecordDeclaration elixirRecordDeclaration
let b:current_syntax = "elixir"
if main_syntax == "elixir"
unlet main_syntax
endif
let &cpo = s:cpo_save
unlet s:cpo_save

16
sources_non_forked/vim-elixir/test.init.vim Normal file
View File

@ -0,0 +1,16 @@
set runtimepath+=/root/vim-elixir
runtime ftdetect/elixir.vim
filetype plugin indent on
set ruler
set hidden
let g:elixir_indent_debug=1
let mapleader=","
map <leader>syn :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<'
\ . synIDattr(synID(line("."),col("."),0),"name") . "> lo<"
\ . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"<CR>

16
sources_non_forked/vim-elixir/test.vimrc Normal file
View File

@ -0,0 +1,16 @@
set runtimepath+=/root/vim-elixir
runtime ftdetect/elixir.vim
filetype plugin indent on
set ruler
set hidden
let g:elixir_indent_debug=1
let mapleader=","
map <leader>syn :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name") . '> trans<'
\ . synIDattr(synID(line("."),col("."),0),"name") . "> lo<"
\ . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name") . ">"<CR>