gsettings set $gnome-schema font-name “Sans 12”

gsettings set $gnome-schema font-name “Sans 10”

profile.log
test_indent.result
doc/tags
.gvim_path

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"

FROM ubuntu:latest
RUN apt-get update && apt-get install -yf vim
COPY test.vimrc /root/.vimrc

# 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

source 'https://rubygems.org'
gem 'rspec'
gem 'vimrunner'
gem 'pry'
gem 'diffy'
gem 'parallel_tests'

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

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
```

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.

# 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

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

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()

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

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

#! /usr/bin/env sh
docker-compose build
docker-compose run nvim nvim $1

#! /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"

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

#!/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")

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

#! /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'

#! /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'

#! /usr/bin/env sh
docker-compose build
docker-compose run vim

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

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:

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

*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

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

au BufRead,BufNewFile *.ex,*.exs set filetype=elixir
au BufRead,BufNewFile *.eex,*.heex,*.leex,*.sface,*.lexs set filetype=eelixir
au BufRead,BufNewFile mix.lock set filetype=elixir
au BufRead,BufNewFile * call s:DetectElixir()
function! s:DetectElixir()
  if (!did_filetype() || &filetype !=# 'elixir') && getline(1) =~# '^#!.*\<elixir\>'
    set filetype=elixir
  endif
endfunction

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

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'

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

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

defmodule GenStage do
  @moduledoc ~S"""
  Stages are data-exchange steps that send and/or receive data
  from other stages.
  When a stage sends data, it acts as a producer. When it receives
  data, it acts as a consumer. Stages may take both producer and
  consumer roles at once.
  ## Stage types
  Besides taking both producer and consumer roles, a stage may be
  called "source" if it only produces items or called "sink" if it
  only consumes items.
  For example, imagine the stages below where A sends data to B
  that sends data to C:
      [A] -> [B] -> [C]
  we conclude that:
    * A is only a producer (and therefore a source)
    * B is both producer and consumer
    * C is only a consumer (and therefore a sink)
  As we will see in the upcoming Examples section, we must
  specify the type of the stage when we implement each of them.
  To start the flow of events, we subscribe consumers to
  producers. Once the communication channel between them is
  established, consumers will ask the producers for events.
  We typically say the consumer is sending demand upstream.
  Once demand arrives, the producer will emit items, never
  emitting more items than the consumer asked for. This provides
  a back-pressure mechanism.
  A consumer may have multiple producers and a producer may have
  multiple consumers. When a consumer asks for data, each producer
  is handled separately, with its own demand. When a producer
  receives demand and sends data to multiple consumers, the demand
  is tracked and the events are sent by a dispatcher. This allows
  producers to send data using different "strategies". See
  `GenStage.Dispatcher` for more information.
  Many developers tend to create layers of stages, such as A, B and
  C, for achieving concurrency. If all you want is concurrency, using
  processes is enough. They are the primitive for achieving concurrency
  in Elixir and the VM does all of the work of multiplexing them.
  Instead, layers in GenStage must be created when there is a need for
  back-pressure or to route the data in different ways.
  For example, if you need the data to go over multiple steps but
  without a need for back-pressure or without a need to break the
  data apart, do not design it as such:
      [Producer] -> [Step 1] -> [Step 2] -> [Step 3]
  Instead it is better to design it as:
                   [Consumer]
                  /
      [Producer]-<-[Consumer]
                  \
                   [Consumer]
  where "Consumer" are multiple processes that subscribe to the same
  "Producer" and run exactly the same code, with all of transformation
  steps from above. In such scenarios, you may even find the
  `Task.async_stream/2` function that ships as part of Elixir to be
  enough or achieve the flexibility you need with the `ConsumerSupervisor`
  functionality that is included as part of `GenStage`.
  ## Example
  Let's define the simple pipeline below:
      [A] -> [B] -> [C]
  where A is a producer that will emit items starting from 0,
  B is a producer-consumer that will receive those items and
  multiply them by a given number and C will receive those events
  and print them to the terminal.
  Let's start with A. Since A is a producer, its main
  responsibility is to receive demand and generate events.
  Those events may be in memory or an external queue system.
  For simplicity, let's implement a simple counter starting
  from a given value of `counter` received on `init/1`:
      defmodule A do
        use GenStage
        def start_link(number) do
          GenStage.start_link(A, number)
        end
        def init(counter) do
          {:producer, counter}
        end
        def handle_demand(demand, counter) when demand > 0 do
          # If the counter is 3 and we ask for 2 items, we will
          # emit the items 3 and 4, and set the state to 5.
          events = Enum.to_list(counter..counter+demand-1)
          {:noreply, events, counter + demand}
        end
      end
  B is a producer-consumer. This means it does not explicitly
  handle the demand because the demand is always forwarded to
  its producer. Once A receives the demand from B, it will send
  events to B which will be transformed by B as desired. In
  our case, B will receive events and multiply them by a number
  given on initialization and stored as the state:
      defmodule B do
        use GenStage
        def start_link(number) do
          GenStage.start_link(B, number)
        end
        def init(number) do
          {:producer_consumer, number}
        end
        def handle_events(events, _from, number) do
          events = Enum.map(events, & &1 * number)
          {:noreply, events, number}
        end
      end
  C will finally receive those events and print them every second
  to the terminal:
      defmodule C do
        use GenStage
        def start_link() do
          GenStage.start_link(C, :ok)
        end
        def init(:ok) do
          {:consumer, :the_state_does_not_matter}
        end
        def handle_events(events, _from, state) do
          # Wait for a second.
          Process.sleep(1000)
          # Inspect the events.
          IO.inspect(events)
          # We are a consumer, so we would never emit items.
          {:noreply, [], state}
        end
      end
  Now we can start and connect them:
      {:ok, a} = A.start_link(0)  # starting from zero
      {:ok, b} = B.start_link(2)  # multiply by 2
      {:ok, c} = C.start_link()   # state does not matter
      GenStage.sync_subscribe(c, to: b)
      GenStage.sync_subscribe(b, to: a)
  Typically, we subscribe from bottom to top. Since A will
  start producing items only when B connects to it, we want this
  subscription to happen when the whole pipeline is ready. After
  you subscribe all of them, demand will start flowing upstream and
  events downstream.
  When implementing consumers, we often set the `:max_demand` and
  `:min_demand` on subscription. The `:max_demand` specifies the
  maximum amount of events that must be in flow while the `:min_demand`
  specifies the minimum threshold to trigger for more demand. For
  example, if `:max_demand` is 1000 and `:min_demand` is 750,
  the consumer will ask for 1000 events initially and ask for more
  only after it receives at least 250.
  In the example above, B is a `:producer_consumer` and therefore
  acts as a buffer. Getting the proper demand values in B is
  important: making the buffer too small may make the whole pipeline
  slower, making the buffer too big may unnecessarily consume
  memory.
  When such values are applied to the stages above, it is easy
  to see the producer works in batches. The producer A ends-up
  emitting batches of 50 items which will take approximately
  50 seconds to be consumed by C, which will then request another
  batch of 50 items.
  ## `init` and `:subscribe_to`
  In the example above, we have started the processes A, B, and C
  independently and subscribed them later on. But most often it is
  simpler to subscribe a consumer to its producer on its `c:init/1`
  callback. This way, if the consumer crashes, restarting the consumer
  will automatically re-invoke its `c:init/1` callback and resubscribe
  it to the supervisor.
  This approach works as long as the producer can be referenced when
  the consumer starts--such as by name (for a named process) or by pid
  for a running unnamed process. For example, assuming the process
  `A` and `B` are started as follows:
      # Let's call the stage in module A as A
      GenStage.start_link(A, 0, name: A)
      # Let's call the stage in module B as B
      GenStage.start_link(B, 2, name: B)
      # No need to name consumers as they won't be subscribed to
      GenStage.start_link(C, :ok)
  We can now change the `c:init/1` callback for C to the following:
      def init(:ok) do
        {:consumer, :the_state_does_not_matter, subscribe_to: [B]}
      end
  or:
      def init(:ok) do
        {:consumer, :the_state_does_not_matter, subscribe_to: [{B, options}]}
      end
  And we will no longer need to call `sync_subscribe/2`.
  Another advantage of this approach is that it makes it straight-forward
  to leverage concurrency by simply starting multiple consumers that subscribe
  to their producer (or producer-consumer). This can be done in the example above
  by simply calling start link multiple times:
      # Start 4 consumers
      GenStage.start_link(C, :ok)
      GenStage.start_link(C, :ok)
      GenStage.start_link(C, :ok)
      GenStage.start_link(C, :ok)
  In a supervision tree, this is often done by starting multiple workers:
      children = [
        worker(A, [0]),
        worker(B, [2]),
        worker(C, []),
        worker(C, []),
        worker(C, []),
        worker(C, [])
      ]
      Supervisor.start_link(children, strategy: :one_for_one)
  In fact, having multiple consumers is often the easiest and simplest way to
  leverage concurrency in a GenStage pipeline, especially if events can
  be processed out of order. For example, imagine a scenario where you
  have a stream of incoming events and you need to access a number of
  external services per event. Instead of building complex stages that
  route events through those services, one simple mechanism to leverage
  concurrency is to start a producer and N consumers and invoke the external
  services directly for each event in each consumer. N is typically the
  number of cores (as returned by `System.schedulers_online/0`) but can
  likely be increased if the consumers are mostly waiting on IO.
  Another alternative to the scenario above is to use a `ConsumerSupervisor`
  for consuming the events instead of N consumers. The `ConsumerSupervisor`
  will start a separate supervised process per event where the number of children
  is at most `max_demand` and the average amount of children is
  `(max_demand - min_demand) / 2`.
  ## Buffering
  In many situations, producers may attempt to emit events while no consumers
  have yet subscribed. Similarly, consumers may ask producers for events
  that are not yet available. In such cases, it is necessary for producers
  to buffer events until a consumer is available or buffer the consumer
  demand until events arrive, respectively. As we will see next, buffering
  events can be done automatically by `GenStage`, while buffering the demand
  is a case that must be explicitly considered by developers implementing
  producers.
  ### Buffering events
  Due to the concurrent nature of Elixir software, sometimes a producer
  may dispatch events without consumers to send those events to. For example,
  imagine a `:consumer` B subscribes to `:producer` A. Next, the consumer B
  sends demand to A, which starts producing events to satisfy the demand.
  Now, if the consumer B crashes, the producer may attempt to dispatch the
  now produced events but it no longer has a consumer to send those events to.
  In such cases, the producer will automatically buffer the events until another
  consumer subscribes.
  The buffer can also be used in cases where external sources only send
  events in batches larger than asked for. For example, if you are
  receiving events from an external source that only sends events
  in batches of 1000 and the internal demand is smaller than
  that, the buffer allows you to always emit batches of 1000 events
  even when the consumer has asked for less.
  In all of those cases when an event cannot be sent immediately by
  a producer, the event will be automatically stored and sent the next
  time consumers ask for events. The size of the buffer is configured
  via the `:buffer_size` option returned by `init/1` and the default
  value is `10_000`. If the `buffer_size` is exceeded, an error is logged.
  See the documentation for `c:init/1` for more detailed infromation about
  the `:buffer_size` option.
  ### Buffering demand
  In case consumers send demand and the producer is not yet ready to
  fill in the demand, producers must buffer the demand until data arrives.
  As an example, let's implement a producer that broadcasts messages
  to consumers. For producers, we need to consider two scenarios:
    1. what if events arrive and there are no consumers?
    2. what if consumers send demand and there are not enough events?
  One way to implement such a broadcaster is to simply rely on the internal
  buffer available in `GenStage`, dispatching events as they arrive, as explained
  in the previous section:
      defmodule Broadcaster do
        use GenStage
        @doc "Starts the broadcaster."
        def start_link() do
          GenStage.start_link(__MODULE__, :ok, name: __MODULE__)
        end
        @doc "Sends an event and returns only after the event is dispatched."
        def sync_notify(event, timeout \\ 5000) do
          GenStage.call(__MODULE__, {:notify, event}, timeout)
        end
        def init(:ok) do
          {:producer, :ok, dispatcher: GenStage.BroadcastDispatcher}
        end
        def handle_call({:notify, event}, _from, state) do
          {:reply, :ok, [event], state} # Dispatch immediately
        end
        def handle_demand(_demand, state) do
          {:noreply, [], state} # We don't care about the demand
        end
      end
  By always sending events as soon as they arrive, if there is any demand,
  we will serve the existing demand, otherwise the event will be queued in
  `GenStage`'s internal buffer. In case events are being queued and not being
  consumed, a log message will be emitted when we exceed the `:buffer_size`
  configuration.
  While the implementation above is enough to solve the constraints above,
  a more robust implementation would have tighter control over the events
  and demand by tracking this data locally, leaving the `GenStage` internal
  buffer only for cases where consumers crash without consuming all data.
  To handle such cases, we will use a two-element tuple as the broadcaster state
  where the first elemeent is a queue and the second element is the pending
  demand.  When events arrive and there are no consumers, we will store the
  event in the queue alongside information about the process that broadcasted
  the event. When consumers send demand and there are not enough events, we will
  increase the pending demand.  Once we have both data and demand, we
  acknowledge the process that has sent the event to the broadcaster and finally
  broadcast the event downstream.
      defmodule QueueBroadcaster do
        use GenStage
        @doc "Starts the broadcaster."
        def start_link() do
          GenStage.start_link(__MODULE__, :ok, name: __MODULE__)
        end
        @doc "Sends an event and returns only after the event is dispatched."
        def sync_notify(event, timeout \\ 5000) do
          GenStage.call(__MODULE__, {:notify, event}, timeout)
        end
        ## Callbacks
        def init(:ok) do
          {:producer, {:queue.new, 0}, dispatcher: GenStage.BroadcastDispatcher}
        end
        def handle_call({:notify, event}, from, {queue, pending_demand}) do
          queue = :queue.in({from, event}, queue)
          dispatch_events(queue, pending_demand, [])
        end
        def handle_demand(incoming_demand, {queue, pending_demand}) do
          dispatch_events(queue, incoming_demand + pending_demand, [])
        end
        defp dispatch_events(queue, 0, events) do
          {:noreply, Enum.reverse(events), {queue, 0}}
        end
        defp dispatch_events(queue, demand, events) do
          case :queue.out(queue) do
            {{:value, {from, event}}, queue} ->
              GenStage.reply(from, :ok)
              dispatch_events(queue, demand - 1, [event | events])
            {:empty, queue} ->
              {:noreply, Enum.reverse(events), {queue, demand}}
          end
        end
      end
  Let's also implement a consumer that automatically subscribes to the
  broadcaster on `c:init/1`. The advantage of doing so on initialization
  is that, if the consumer crashes while it is supervised, the subscription
  is automatically re-established when the supervisor restarts it.
      defmodule Printer do
        use GenStage
        @doc "Starts the consumer."
        def start_link() do
          GenStage.start_link(__MODULE__, :ok)
        end
        def init(:ok) do
          # Starts a permanent subscription to the broadcaster
          # which will automatically start requesting items.
          {:consumer, :ok, subscribe_to: [QueueBroadcaster]}
        end
        def handle_events(events, _from, state) do
          for event <- events do
            IO.inspect {self(), event}
          end
          {:noreply, [], state}
        end
      end
  With the broadcaster in hand, now let's start the producer as well
  as multiple consumers:
      # Start the producer
      QueueBroadcaster.start_link()
      # Start multiple consumers
      Printer.start_link()
      Printer.start_link()
      Printer.start_link()
      Printer.start_link()
  At this point, all consumers must have sent their demand which we were not
  able to fulfill. Now by calling `QueueBroadcaster.sync_notify/1`, the event
  shall be broadcasted to all consumers at once as we have buffered the demand
  in the producer:
      QueueBroadcaster.sync_notify(:hello_world)
  If we had called `QueueBroadcaster.sync_notify(:hello_world)` before any
  consumer was available, the event would also have been buffered in our own
  queue and served only when demand had been received.
  By having control over the demand and queue, the broadcaster has
  full control on how to behave when there are no consumers, when the
  queue grows too large, and so forth.
  ## Asynchronous work and `handle_subscribe`
  Both `:producer_consumer` and `:consumer` stages have been designed to do
  their work in the `c:handle_events/3` callback. This means that, after
  `c:handle_events/3` is invoked, both `:producer_consumer` and `:consumer`
  stages will immediately send demand upstream and ask for more items, as the
  stage that produced the events assumes events have been fully processed by
  `c:handle_events/3`.
  Such default behaviour makes `:producer_consumer` and `:consumer` stages
  unfeasible for doing asynchronous work. However, given `GenStage` was designed
  to run with multiple consumers, it is not a problem to perform synchronous or
  blocking actions inside `handle_events/3` as you can then start multiple
  consumers in order to max both CPU and IO usage as necessary.
  On the other hand, if you must perform some work asynchronously,
  `GenStage` comes with an option that manually controls how demand
  is sent upstream, avoiding the default behaviour where demand is
  sent after `c:handle_events/3`. Such can be done by implementing
  the `c:handle_subscribe/4` callback and returning `{:manual, state}`
  instead of the default `{:automatic, state}`. Once the producer mode
  is set to `:manual`, developers must use `GenStage.ask/3` to send
  demand upstream when necessary.
  Note that when `:max_demand` and `:min_demand` must be manually respected when
  manually asking for demand through `GenStage.ask/3`.
  For example, the `ConsumerSupervisor` module processes events
  asynchronously by starting a process for each event and this is achieved by
  manually sending demand to producers. `ConsumerSupervisor`
  can be used to distribute work to a limited amount of
  processes, behaving similar to a pool where a new process is
  started for each event. See the `ConsumerSupervisor` docs for more
  information.
  Setting the demand to `:manual` in `c:handle_subscribe/4` is not
  only useful for asynchronous work but also for setting up other
  mechanisms for back-pressure. As an example, let's implement a
  consumer that is allowed to process a limited number of events
  per time interval. Those are often called rate limiters:
      defmodule RateLimiter do
        use GenStage
        def init(_) do
          # Our state will keep all producers and their pending demand
          {:consumer, %{}}
        end
        def handle_subscribe(:producer, opts, from, producers) do
          # We will only allow max_demand events every 5000 milliseconds
          pending = opts[:max_demand] || 1000
          interval = opts[:interval] || 5000
          # Register the producer in the state
          producers = Map.put(producers, from, {pending, interval})
          # Ask for the pending events and schedule the next time around
          producers = ask_and_schedule(producers, from)
          # Returns manual as we want control over the demand
          {:manual, producers}
        end
        def handle_cancel(_, from, producers) do
          # Remove the producers from the map on unsubscribe
          {:noreply, [], Map.delete(producers, from)}
        end
        def handle_events(events, from, producers) do
          # Bump the amount of pending events for the given producer
          producers = Map.update!(producers, from, fn {pending, interval} ->
            {pending + length(events), interval}
          end)
          # Consume the events by printing them.
          IO.inspect(events)
          # A producer_consumer would return the processed events here.
          {:noreply, [], producers}
        end
        def handle_info({:ask, from}, producers) do
          # This callback is invoked by the Process.send_after/3 message below.
          {:noreply, [], ask_and_schedule(producers, from)}
        end
        defp ask_and_schedule(producers, from) do
          case producers do
            %{^from => {pending, interval}} ->
              # Ask for any pending events
              GenStage.ask(from, pending)
              # And let's check again after interval
              Process.send_after(self(), {:ask, from}, interval)
              # Finally, reset pending events to 0
              Map.put(producers, from, {0, interval})
            %{} ->
              producers
          end
        end
      end
  Let's subscribe the `RateLimiter` above to the
  producer we have implemented at the beginning of the module
  documentation:
      {:ok, a} = GenStage.start_link(A, 0)
      {:ok, b} = GenStage.start_link(RateLimiter, :ok)
      # Ask for 10 items every 2 seconds
      GenStage.sync_subscribe(b, to: a, max_demand: 10, interval: 2000)
  Although the rate limiter above is a consumer, it could be made a
  producer-consumer by changing `c:init/1` to return a `:producer_consumer`
  and then forwarding the events in `c:handle_events/3`.
  ## Notifications
  `GenStage` also supports the ability to send notifications to all
  consumers. Those notifications are sent as regular messages outside
  of the demand-driven protocol but respecting the event ordering.
  See `sync_notify/3` and `async_notify/2`.
  Notifications are useful for out-of-band information, for example,
  to notify consumers the producer has sent all events it had to
  process or that a new batch of events is starting.
  Note the notification system should not be used for broadcasting
  events; for such, consider using `GenStage.BroadcastDispatcher`.
  ## Callbacks
  `GenStage` is implemented on top of a `GenServer` with a few additions.
  Besides exposing all of the `GenServer` callbacks, it also provides
  `handle_demand/2` to be implemented by producers and `handle_events/3` to be
  implemented by consumers, as shown above, as well as subscription-related
  callbacks. Furthermore, all the callback responses have been modified to
  potentially emit events. See the callbacks documentation for more
  information.
  By adding `use GenStage` to your module, Elixir will automatically
  define all callbacks for you except for the following ones:
    * `init/1` - must be implemented to choose between `:producer`, `:consumer`, or `:producer_consumer` stages
    * `handle_demand/2` - must be implemented by `:producer` stages
    * `handle_events/3` - must be implemented by `:producer_consumer` and `:consumer` stages
  Although this module exposes functions similar to the ones found in
  the `GenServer` API, like `call/3` and `cast/2`, developers can also
  rely directly on GenServer functions such as `GenServer.multi_call/4`
  and `GenServer.abcast/3` if they wish to.
  ### Name registration
  `GenStage` is bound to the same name registration rules as a `GenServer`.
  Read more about it in the `GenServer` docs.
  ## Message protocol overview
  This section will describe the message protocol implemented
  by stages. By documenting these messages, we will allow
  developers to provide their own stage implementations.
  ### Back-pressure
  When data is sent between stages, it is done by a message
  protocol that provides back-pressure. The first step is
  for the consumer to subscribe to the producer. Each
  subscription has a unique reference.
  Once subscribed, the consumer may ask the producer for messages
  for the given subscription. The consumer may demand more items
  whenever it wants to. A consumer must never receive more data
  than it has asked for from any given producer stage.
  A consumer may have multiple producers, where each demand is managed
  individually (on a per-subscription basis). A producer may have multiple
  consumers, where the demand and events are managed and delivered according to
  a `GenStage.Dispatcher` implementation.
  ### Producer messages
  The producer is responsible for sending events to consumers
  based on demand. These are the messages that consumers can
  send to producers:
    * `{:"$gen_producer", from :: {consumer_pid, subscription_tag}, {:subscribe, current, options}}` -
      sent by the consumer to the producer to start a new subscription.
      Before sending, the consumer MUST monitor the producer for clean-up
      purposes in case of crashes. The `subscription_tag` is unique to
      identify the subscription. It is typically the subscriber monitoring
      reference although it may be any term.
      Once sent, the consumer MAY immediately send demand to the producer.
      The `current` field, when not `nil`, is a two-item tuple containing a
      subscription that must be cancelled with the given reason before the
      current one is accepted.
      Once received, the producer MUST monitor the consumer. However, if
      the subscription reference is known, it MUST send a `:cancel` message
      to the consumer instead of monitoring and accepting the subscription.
    * `{:"$gen_producer", from :: {consumer_pid, subscription_tag}, {:cancel, reason}}` -
      sent by the consumer to cancel a given subscription.
      Once received, the producer MUST send a `:cancel` reply to the
      registered consumer (which may not necessarily be the one received
      in the tuple above). Keep in mind, however, there is no guarantee
      such messages can be delivered in case the producer crashes before.
      If the pair is unknown, the producer MUST send an appropriate cancel
      reply.
    * `{:"$gen_producer", from :: {consumer_pid, subscription_tag}, {:ask, demand}}` -
      sent by consumers to ask demand for a given subscription (identified
      by `subscription_tag`).
      Once received, the producer MUST send data up to the demand. If the
      pair is unknown, the producer MUST send an appropriate cancel reply.
  ### Consumer messages
  The consumer is responsible for starting the subscription
  and sending demand to producers. These are the messages that
  producers can send to consumers:
    * `{:"$gen_consumer", from :: {producer_pid, subscription_tag}, {:notification, message}}` -
      notifications sent by producers.
    * `{:"$gen_consumer", from :: {producer_pid, subscription_tag}, {:cancel, reason}}` -
      sent by producers to cancel a given subscription.
      It is used as a confirmation for client cancellations OR
      whenever the producer wants to cancel some upstream demand.
    * `{:"$gen_consumer", from :: {producer_pid, subscription_tag}, events :: [event, ...]}` -
      events sent by producers to consumers.
      `subscription_tag` identifies the subscription. The third argument
      is a non-empty list of events. If the subscription is unknown, the
      events must be ignored and a cancel message must be sent to the producer.
  """
  defstruct [:mod, :state, :type, :dispatcher_mod, :dispatcher_state, :buffer,
             :buffer_config, events: :forward, monitors: %{}, producers: %{}, consumers: %{}]
  @typedoc "The supported stage types."
  @type type :: :producer | :consumer | :producer_consumer
  @typedoc "The supported init options."
  @type options :: keyword()
  @typedoc "The stage."
  @type stage :: pid | atom | {:global, term} | {:via, module, term} | {atom, node}
  @typedoc "The term that identifies a subscription."
  @opaque subscription_tag :: reference
  @typedoc "The term that identifies a subscription associated with the corresponding producer/consumer."
  @type from :: {pid, subscription_tag}
  @doc """
  Invoked when the server is started.
  `start_link/3` (or `start/3`) will block until this callback returns.
  `args` is the argument term (second argument) passed to `start_link/3`
  (or `start/3`).
  In case of successful start, this callback must return a tuple
  where the first element is the stage type, which is one of:
    * `:producer`
    * `:consumer`
    * `:producer_consumer` (if the stage is acting as both)
  For example:
      def init(args) do
        {:producer, some_state}
      end
  The returned tuple may also contain 3 or 4 elements. The third
  element may be the `:hibernate` atom or a set of options defined
  below.
  Returning `:ignore` will cause `start_link/3` to return `:ignore`
  and the process will exit normally without entering the loop or
  calling `terminate/2`.
  Returning `{:stop, reason}` will cause `start_link/3` to return
  `{:error, reason}` and the process to exit with reason `reason`
  without entering the loop or calling `terminate/2`.
  ## Options
  This callback may return options. Some options are specific to
  the chosen stage type while others are shared across all types.
  ### `:producer` options
    * `:demand` - when `:forward`, the demand is always forwarded to
      the `c:handle_demand/2` callback. When `:accumulate`, demand is
      accumulated until its mode is set to `:forward` via `demand/2`.
      This is useful as a synchronization mechanism, where the demand
      is accumulated until all consumers are subscribed. Defaults to
      `:forward`.
  ### `:producer` and `:producer_consumer` options
    * `:buffer_size` - the size of the buffer to store events without
      demand. Can be `:infinity` to signal no limit on the buffer size. Check
      the "Buffer events" section of the module documentation. Defaults to
      `10_000` for `:producer`, `:infinity` for `:producer_consumer`.
    * `:buffer_keep` - returns whether the `:first` or `:last` entries
      should be kept on the buffer in case the buffer size is exceeded.
      Defaults to `:last`.
    * `:dispatcher` - the dispatcher responsible for handling demands.
      Defaults to `GenStage.DemandDispatch`. May be either an atom
      representing a dispatcher module or a two-element tuple with
      the dispatcher module and the dispatcher options.
  ### `:consumer` and `:producer_consumer` options
    * `:subscribe_to` - a list of producers to subscribe to. Each element
      represents either the producer module or a tuple with the producer module
      and the subscription options (as defined in `sync_subscribe/2`).
  """
  @callback init(args :: term) ::
    {type, state} |
    {type, state, options} |
    :ignore |
    {:stop, reason :: any} when state: any
  @doc """
  Invoked on `:producer` stages.
  This callback is invoked on `:producer` stages with the demand from
  consumers/dispatcher. The producer that implements this callback must either
  store the demand, or return the amount of requested events.
  Must always be explicitly implemented by `:producer` stages.
  ## Examples
      def handle_demand(demand, state) do
        # We check if we're able to satisfy the demand and fetch
        # events if we aren't.
        events =
          if length(state.events) >= demand do
            events
          else
            fetch_events()
          end
        # We dispatch only the requested number of events.
        {to_dispatch, remaining} = Enum.split(events, demand)
        {:noreply, to_dispatch, %{state | events: remaining}}
      end
  """
  @callback handle_demand(demand :: pos_integer, state :: term) ::
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason, new_state} when new_state: term, reason: term, event: term
  @doc """
  Invoked when a consumer subscribes to a producer.
  This callback is invoked in both producers and consumers.
  `producer_or_consumer` will be `:producer` when this callback is
  invoked on a consumer that subscribed to a producer, and `:consumer`
  if when this callback is invoked on producers a consumer subscribed to.
  For consumers, successful subscriptions must return one of:
    * `{:automatic, new_state}` - means the stage implementation will take care
      of automatically sending demand to producers. This is the default.
    * `{:manual, state}` - means that demand must be sent to producers
      explicitly via `ask/3`. `:manual` subscriptions must be cancelled when
      `c:handle_cancel/3` is called. `:manual` can be used when a special
      behaviour is desired (for example, `ConsumerSupervisor` uses `:manual`
      demand in its implementation).
  For producers, successful subscriptions must always return
  `{:automatic, new_state}`. `:manual` mode is not supported.
  If this callback is not implemented, the default implementation by
  `use GenStage` will return `{:automatic, state}`.
  ## Examples
  Let's see an example where we define this callback in a consumer that will use
  `:manual` mode. In this case, we'll store the subscription (`from`) in the
  state in order to be able to use it later on when asking demand via `ask/3`.
      def handle_subscribe(:producer, _options, from, state) do
        new_state = %{state | subscription: from}
        {:manual, new_state
      end
  """
  @callback handle_subscribe(producer_or_consumer :: :producer | :consumer, options, from, state :: term) ::
    {:automatic | :manual, new_state} |
    {:stop, reason, new_state} when new_state: term, reason: term
  @doc """
  Invoked when a consumer is no longer subscribed to a producer.
  It receives the cancellation reason, the `from` tuple representing the
  cancelled subscription and the state.  The `cancel_reason` will be a
  `{:cancel, _}` tuple if the reason for cancellation was a `GenStage.cancel/2`
  call. Any other value means the cancellation reason was due to an EXIT.
  If this callback is not implemented, the default implementation by
  `use GenStage` will return `{:noreply, [], state}`.
  Return values are the same as `c:handle_cast/2`.
  """
  @callback handle_cancel(cancellation_reason :: {:cancel | :down, reason :: term}, from, state :: term) ::
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason, new_state} when event: term, new_state: term, reason: term
  @doc """
  Invoked on `:producer_consumer` and `:consumer` stages to handle events.
  Must always be explicitly implemented by such types.
  Return values are the same as `c:handle_cast/2`.
  """
  @callback handle_events(events :: [event], from, state :: term) ::
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason, new_state} when new_state: term, reason: term, event: term
  @doc """
  Invoked to handle synchronous `call/3` messages.
  `call/3` will block until a reply is received (unless the call times out or
  nodes are disconnected).
  `request` is the request message sent by a `call/3`, `from` is a two-element tuple
  containing the caller's PID and a term that uniquely identifies the call, and
  `state` is the current state of the `GenStage`.
  Returning `{:reply, reply, [events], new_state}` sends the response `reply`
  to the caller after events are dispatched (or buffered) and continues the
  loop with new state `new_state`. In case you want to deliver the reply before
  processing events, use `reply/2` and return `{:noreply, [event],
  state}`.
  Returning `{:noreply, [event], new_state}` does not send a response to the
  caller and processes the given events before continuing the loop with new
  state `new_state`. The response must be sent with `reply/2`.
  Hibernating is also supported as an atom to be returned from either
  `:reply` and `:noreply` tuples.
  Returning `{:stop, reason, reply, new_state}` stops the loop and `terminate/2`
  is called with reason `reason` and state `new_state`. Then the `reply` is sent
  as the response to the call and the process exits with reason `reason`.
  Returning `{:stop, reason, new_state}` is similar to
  `{:stop, reason, reply, new_state}` except that no reply is sent to the caller.
  If this callback is not implemented, the default implementation by
  `use GenStage` will return `{:stop, {:bad_call, request}, state}`.
  """
  @callback handle_call(request :: term, from :: GenServer.from, state :: term) ::
    {:reply, reply, [event], new_state} |
    {:reply, reply, [event], new_state, :hibernate} |
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason, reply, new_state} |
    {:stop, reason, new_state} when reply: term, new_state: term, reason: term, event: term
  @doc """
  Invoked to handle asynchronous `cast/2` messages.
  `request` is the request message sent by a `cast/2` and `state` is the current
  state of the `GenStage`.
  Returning `{:noreply, [event], new_state}` dispatches the events and continues
  the loop with new state `new_state`.
  Returning `{:noreply, [event], new_state, :hibernate}` is similar to
  `{:noreply, new_state}` except the process is hibernated before continuing the
  loop. See the return values for `c:GenServer.handle_call/3` for more information
  on hibernation.
  Returning `{:stop, reason, new_state}` stops the loop and `terminate/2` is
  called with the reason `reason` and state `new_state`. The process exits with
  reason `reason`.
  If this callback is not implemented, the default implementation by
  `use GenStage` will return `{:stop, {:bad_cast, request}, state}`.
  """
  @callback handle_cast(request :: term, state :: term) ::
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason :: term, new_state} when new_state: term, event: term
  @doc """
  Invoked to handle all other messages.
  `message` is the message and `state` is the current state of the `GenStage`. When
  a timeout occurs the message is `:timeout`.
  If this callback is not implemented, the default implementation by
  `use GenStage` will return `{:noreply, [], state}`.
  Return values are the same as `c:handle_cast/2`.
  """
  @callback handle_info(message :: term, state :: term) ::
    {:noreply, [event], new_state} |
    {:noreply, [event], new_state, :hibernate} |
    {:stop, reason :: term, new_state} when new_state: term, event: term
  @doc """
  The same as `c:GenServer.terminate/2`.
  """
  @callback terminate(reason, state :: term) ::
    term when reason: :normal | :shutdown | {:shutdown, term} | term
  @doc """
  The same as `c:GenServer.code_change/3`.
  """
  @callback code_change(old_vsn, state :: term, extra :: term) ::
    {:ok, new_state :: term} |

#!/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

# 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

# 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

# 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
        :yo -> :dawg
        :high -> :low
      end
    end
  end
  EOF
  i <<~EOF
  defmodule Hello do
    def hello do
      case word do
        :yo -> :dawg
        :high -> :low
      end
    end
  end
  EOF
  i <<~EOF
  defmodule Hello do
    def hello do
      case word do
        :yo ->
          :dawg
        :high ->
          :low
      end
    end
  end
  EOF
  i <<~EOF
  defmodule Hello do
    def hello do
      case word do
        :yo ->
          case word do
            :yo ->
              :dawg
            :high ->
              :low
          end
          :dawg
        :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 =
        "josh"
      street =
        "newbury"
    end
  end
  EOF
  %w(= == === != !== <= >= <> && || + - * / ~~~ ^^^ <<< >>> ||| &&&).each do |bin_op|
    i <<~EOF
    defmodule Hello do
      def hello do
        name #{bin_op}
          "josh"
        street #{bin_op}
          "newbury"
      end
    end
    EOF
    i <<~EOF
    defmodule Hello do
      def hello do
        name #{bin_op} "josh"
        street #{bin_op} "newbury"
      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 = "josh"
      street = "newbury"
    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
          :yo ->
            case word do
              :yo ->
                :dawg
              :high ->
                :low
            end
            :dawg
          :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 "wtf"
      rescue
        e in errs ->
          IO.puts "yo"
        _ ->
          IO.puts "yo"
      end
    end
  end
  EOF
  i <<~EOF
  defmodule Hi do
    defp hi do
      try do
        raise "wtf"
      catch
        e ->
          IO.puts "yo"
        _ ->
          IO.puts "yo"
      end
    end
  end
  EOF
  i <<~EOF
  defmodule Hi do
    defp hi do
      receive do
        {:hello, world} ->
          :ok
      after
        1000 ->
          IO.puts "yo"
        2000 ->
          IO.puts "yo"
      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

# 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

# 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

# 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

# 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

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

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

# 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

# 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

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

# 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

# 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