Merge 9d72894faf into 5ecf2c0bc8

sources_non_forked/vim-scala/.gitignore

@@ -0,0 +1,6 @@
+# Ignore Vim tag files
+tags
+
+# Ignore Vim swap files
+.*.swp
+.*.swo

sources_non_forked/vim-scala/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+before_install: sudo apt-get install vim-gtk
+before_script:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"
+notifications:
+  email:
+    on_success: never
+    on_failure: change

sources_non_forked/vim-scala/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gem 'vimrunner', '0.3.0'
+gem 'rake',      '10.0.4'
+gem 'rspec',     '~> 2.13.0'
+

sources_non_forked/vim-scala/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rake (0.9.2.2)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rspec

sources_non_forked/vim-scala/LICENSE.TXT

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "{}"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright {yyyy} {name of copyright owner}
+
+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.

sources_non_forked/vim-scala/README.md

@@ -0,0 +1,63 @@
+vim-scala
+=========
+
+This is a "bundle" for Vim that builds off of the initial Scala plugin modules
+by Stefan Matthias Aust and adds some more "stuff" that I find useful, including
+all of my notes and customizations.
+
+## Installation
+
+You really should be using Tim Pope's [Pathogen](https://github.com/tpope/vim-pathogen) module for Vim (http://tammersaleh.com/posts/the-modern-vim-config-with-pathogen) if you're going to clone this repository because, well... you should.
+
+### Using the command-line
+
+Using wget:
+
+```mkdir -p ~/.vim/{ftdetect,indent,syntax} && for d in ftdetect indent syntax ; do wget -O ~/.vim/$d/scala.vim https://raw.githubusercontent.com/derekwyatt/vim-scala/master/$d/scala.vim; done```
+
+Using cURL:
+
+```mkdir -p ~/.vim/{ftdetect,indent,syntax} && for d in ftdetect indent syntax ; do curl -o ~/.vim/$d/scala.vim https://raw.githubusercontent.com/derekwyatt/vim-scala/master/$d/scala.vim; done```
+
+### Vundle
+Alternatively, you can use [Vundle](https://github.com/gmarik/vundle) to
+manage your plugins.
+
+If you have Vundle installed, simply add the following to your .vimrc:
+
+```vim
+Plugin 'derekwyatt/vim-scala'
+```
+
+and then run
+
+```vim
+:PluginInstall
+```
+
+to install it.
+
+## Sorting of import statements
+    :SortScalaImports
+
+There are different modes for import sorting available. For details, please
+consult the vimdoc help with
+
+    :help :SortScalaImports
+
+## Scaladoc comment indentation
+
+By default, the plugin indents documentation comments according to the standard
+Javadoc format
+
+    /**
+     * This is a doc comment using Javadoc-style indentation.
+     */
+
+To enable the indentation standard as recommended for Scaladoc comments (from
+http://docs.scala-lang.org/style/scaladoc.html, since Scaladoc2), add the
+command ``let g:scala_scaladoc_indent = 1`` to .vimrc file, e.g:
+
+    /** This is a Scaladoc comment using the recommended indentation.
+      * let g:scala_scaladoc_indent = 1
+      */

sources_non_forked/vim-scala/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec

sources_non_forked/vim-scala/after/syntax/help.vim

@@ -0,0 +1,14 @@
+" Extends standard help syntax with highlighting of Scala code.
+"
+" Place code between !sc! and !/sc! delimiters. These will be hidden if Vim is
+" built with conceal support.
+
+unlet! b:current_syntax
+
+syntax include @ScalaCode syntax/scala.vim
+
+if has('conceal')
+  syntax region rgnScala matchgroup=Ignore concealends start='!sc!' end='!/sc!' contains=@ScalaCode
+else
+  syntax region rgnScala matchgroup=Ignore start='!sc!' end='!/sc!' contains=@ScalaCode
+endif

sources_non_forked/vim-scala/compiler/sbt.vim

@@ -0,0 +1,30 @@
+" Vim compiler file
+" Language:             Scala SBT (http://www.scala-sbt.org/)
+" Maintainer:           Derek Wyatt
+" URL:                  https://github.com/derekwyatt/vim-scala
+" License:              Apache 2
+" ----------------------------------------------------------------------------
+
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'sbt'
+
+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=sbt\ -Dsbt.log.noformat=true\ compile
+
+CompilerSet errorformat=
+      \%E\ %#[error]\ %f:%l:\ %m,%C\ %#[error]\ %p^,%-C%.%#,%Z,
+      \%W\ %#[warn]\ %f:%l:\ %m,%C\ %#[warn]\ %p^,%-C%.%#,%Z,
+      \%-G%.%#
+
+let &cpo = s:cpo_save
+unlet s:cpo_save
+
+" vim:set sw=2 sts=2 ts=8 et:

sources_non_forked/vim-scala/ctags/scala.ctags

@@ -0,0 +1,13 @@
+--langdef=scala
+--langmap=scala:.scala
+
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy)[ \t]*)*(private[^ ]*|protected)?[ \t]*class[ \t]+([a-zA-Z0-9_]+)/\4/c,classes/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy)[ \t]*)*(private[^ ]*|protected)?[ \t]*object[ \t]+([a-zA-Z0-9_]+)/\4/o,objects/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy)[ \t]*)*(private[^ ]*|protected)?[ \t]*((abstract|final|sealed|implicit|lazy)[ \t ]*)*case class[ \t ]+([a-zA-Z0-9_]+)/\6/C,case classes/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy)[ \t]*)*(private[^ ]*|protected)?[ \t]*case object[ \t]+([a-zA-Z0-9_]+)/\4/O,case objects/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy)[ \t]*)*(private[^ ]*|protected)?[ \t]*trait[ \t]+([a-zA-Z0-9_]+)/\4/t,traits/
+--regex-scala=/^[ \t]*type[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy|override|private[^ ]*(\[[a-z]*\])*|protected)[ \t]*)*def[ \t]+([a-zA-Z0-9_]+)/\4/m,methods/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy|override|private[^ ]*|protected)[ \t]*)*val[ \t]+([a-zA-Z0-9_]+)/\3/V,values/
+--regex-scala=/^[ \t]*((abstract|final|sealed|implicit|lazy|override|private[^ ]*|protected)[ \t]*)*var[ \t]+([a-zA-Z0-9_]+)/\3/v,variables/
+--regex-scala=/^[ \t]*package[ \t]+([a-zA-Z0-9_.]+)/\1/p,packages/

sources_non_forked/vim-scala/doc/scala.txt

@@ -0,0 +1,133 @@
+*scala.txt* Syntax highlighting and helper functions for the Scala language.
+
+This plugin is only available if 'compatible' is not set.
+{Vi does not have any of this}
+
+==============================================================================
+INTRODUCTION                                    *scala*
+
+Syntax highlighting and helper functions for the scala language. Extras
+include:
+
+  - Sorting of import statements, configurable to your conventions.
+  - Tagbar support to navigate definitions within a file in the plugin's
+    sidebar window.
+  - ...and probably more that we've forgotten to update in this doc.
+
+==============================================================================
+OPTIONS                                         *scala-options*
+
+Use these options to control behavior of the plugin. Default values are
+indicated in the examples.
+
+                                           *'g:scala_use_builtin_tagbar_defs'*
+If you are using the Tagbar Vim plugin, vim-scala includes a Tagbar type
+definition and ctags definition for Scala, so you can use Tagbar immediately.
+If you have your own ctags definition in `~/.ctags` and prefer to use it, set
+this option to 0 (we would appreciate contributions if you've improved the
+ctags definition!).
+
+Note that Tagbar's ctags definition for Scala is not used to generate a
+|tags| file that Vim can use to navigate to definitions in other files, only
+for the plugin sidebar. Feel free to copy `vim-scala/ctags/scala.ctags` into
+your own `~/.ctags` if you wish to generate |tags| files.
+>
+    let g:scala_use_builtin_tagbar_defs = 1
+<
+                                           *'g:scala_use_default_keymappings'*
+Set this option to disable definition of all mappings provided by vim-scala.
+See |scala-mappings|.
+>
+    let g:scala_use_default_keymappings = 1
+<
+
+                                                   *'g:scala_scaladoc_indent'*
+By default, the plugin indents documentation comments according to the
+standard Javadoc format.
+    /**
+     * This is a doc comment using Javadoc-style indentation.
+     */
+Set this option to enable the indentation standard as recommended for Scaladoc
+comments.
+    /** This is a Scaladoc comment using 
+      * the recommended indentation.
+      */
+>
+    let g:scala_scaladoc_indent = 1
+<
+                                                     
+==============================================================================
+COMMANDS                                        *scala-commands*
+
+                                                *:SortScalaImports*
+:SortScalaImports       There are two modes in which this command can operate.
+                        By default it walks all import groups at the top of
+                        the Scala file and orders their lines alphabetically.
+                        A group is a series of lines starting with the
+                        import keyword separated by one or more blank lines.
+
+                        The second, more advanced mode, can be activated by
+                        setting
+
+                          let g:scala_sort_across_groups=1
+
+                        This makes this command include all imports in the
+                        sorting regardless of blank lines in between them and
+                        puts them in three predefined groups instead.
+                        The three groups in which the imports can fall are:
+
+                          1. Scala and Java core
+                          2. Third party libraries
+                          3. First party code (ie. your own)
+
+                        Java and Scala core imports are identified by the
+                        java(x) and scala namespaces.
+                        Everything else that isn't a first party namespace
+                        will be a third party import.
+                        You can define a regex that matches first party
+                        namespaces by setting
+
+                          g:scala_first_party_namespaces
+
+                        For example in a standard Play app this would be
+                        set to
+                          g:scala_first_party_namespaces=
+                             \ '\(controllers\|views\|models\)'
+
+==============================================================================
+MAPPINGS                                        *scala-mappings*
+
+Currently the only mappings defined are for FuzzyFinder users--these will
+only be enabled if FuzzyFinder is detected.
+
+                                                *scala-leader-fs*
+<Leader>fs              "Find src". Primes |:FufFile| with `src/main/scala`,
+                        and goes deeper still if only a single directory
+                        exists below that. Helpful for package namespacing
+                        like `src/main/scala/com/myorg`.
+
+                                                *scala-leader-ft*
+<Leader>ft              "Find test". Like |scala-leader-fs|, but with
+                        `src/test/scala`.
+
+                                                *scala-leader-fr*
+<Leader>fr              "Find from root". For the rarer cases when you want to
+                        start FuzzyFinder at project root (parent of `src/`).
+
+Disabling Mappings~
+
+If you wish to disable the default key mappings, write the following line in
+your ~/.vimrc: >
+
+    let g:scala_use_default_keymappings = 0
+
+==============================================================================
+CREDITS                                          *scala-credits*
+
+Developed by Derek Wyatt, building on initial work by Stefan Matthias Aust.
+Distributed under the Apache 2 license.
+
+Project's home and Git repository: https://github.com/derekwyatt/vim-scala
+
+------------------------------------------------------------------------------
+ vim:tw=78:ts=8:ft=help:norl:

sources_non_forked/vim-scala/ftdetect/scala.vim

@@ -0,0 +1,11 @@
+fun! s:DetectScala()
+    if getline(1) =~# '^#!\(/usr\)\?/bin/env\s\+scalas\?'
+        set filetype=scala
+    endif
+endfun
+
+au BufRead,BufNewFile *.scala set filetype=scala
+au BufRead,BufNewFile * call s:DetectScala()
+
+" Install vim-sbt for additional syntax highlighting.
+au BufRead,BufNewFile *.sbt setfiletype sbt.scala

sources_non_forked/vim-scala/ftplugin/scala.vim

@@ -0,0 +1,176 @@
+" Vim filetype plugin
+" Language:             Scala
+" Maintainer:           Derek Wyatt
+" URL:                  https://github.com/derekwyatt/vim-scala
+" License:              Apache 2
+" ----------------------------------------------------------------------------
+
+if exists('b:did_ftplugin') || &cp
+  finish
+endif
+let b:did_ftplugin = 1
+
+" j is fairly new in Vim, so don't complain if it's not there
+setlocal formatoptions-=t formatoptions+=croqnl
+silent! setlocal formatoptions+=j
+
+" Just like c.vim, but additionally doesn't wrap text onto /** line when
+" formatting. Doesn't bungle bulleted lists when formatting.
+if get(g:, 'scala_scaladoc_indent', 0)
+  setlocal comments=sO:*\ -,mO:*\ \ ,exO:*/,s2:/**,mb:*,ex:*/,s1:/*,mb:*,ex:*/,://
+else
+  setlocal comments=sO:*\ -,mO:*\ \ ,exO:*/,s1:/**,mb:*,ex:*/,s1:/*,mb:*,ex:*/,://
+endif
+setlocal commentstring=//\ %s
+
+setlocal shiftwidth=2 softtabstop=2 expandtab
+
+setlocal include='^\s*import'
+setlocal includeexpr='substitute(v:fname,"\\.","/","g")'
+
+setlocal path+=src/main/scala,src/test/scala
+setlocal suffixesadd=.scala
+
+compiler sbt
+
+if globpath(&rtp, 'plugin/fuf.vim') != ''
+    "
+    " FuzzyFinder stuff
+    "
+    "
+    " SanitizeDirForFuzzyFinder()
+    "
+    " This is really just a convenience function to clean up any stray '/'
+    " characters in the path, should they be there.
+    "
+    function! scala#SanitizeDirForFuzzyFinder(dir)
+        let dir = expand(a:dir)
+        let dir = substitute(dir, '/\+$', '', '')
+        let dir = substitute(dir, '/\+', '/', '')
+
+        return dir
+    endfunction
+
+    "
+    " GetDirForFuzzyFinder()
+    "
+    " Given a directory to start 'from', walk up the hierarchy, looking for a path
+    " that matches the 'addon' you want to see.
+    "
+    " If nothing can be found, then we just return the 'from' so we don't really get
+    " the advantage of a hint, but just let the user start from wherever he was
+    " starting from anyway.
+    "
+    function! scala#GetDirForFuzzyFinder(from, addon)
+        let from = scala#SanitizeDirForFuzzyFinder(a:from)
+        let addon = expand(a:addon)
+        let addon = substitute(addon, '^/\+', '', '')
+        let found = ''
+        " If the addon is right here, then we win
+        if isdirectory(from . '/' . addon)
+            let found = from . '/' . addon
+        else
+            let dirs = split(from, '/')
+        if !has('win32') && !has('win64')
+          let dirs[0] = '/' . dirs[0]
+        endif
+            " Walk up the tree and see if it's anywhere there
+            for n in range(len(dirs) - 1, 0, -1)
+                let path = join(dirs[0:n], '/')
+                if isdirectory(path . '/' . addon)
+                    let found = path . '/' . addon
+                    break
+                endif
+            endfor
+        endif
+        " If we found it, then let's see if we can go deeper
+        "
+        " For example, we may have found component_name/include
+        " but what if that directory only has a single directory
+        " in it, and that subdirectory only has a single directory
+        " in it, etc... ?  This can happen when you're segmenting
+        " by namespace like this:
+        "
+        "    component_name/include/org/vim/CoolClass.h
+        "
+        " You may find yourself always typing '' from the
+        " 'include' directory just to go into 'org/vim' so let's
+        " just eliminate the need to hit the ''.
+        if found != ''
+            let tempfrom = found
+            let globbed = globpath(tempfrom, '*')
+            while len(split(globbed, "\n")) == 1
+                let tempfrom = globbed
+                let globbed = globpath(tempfrom, '*')
+            endwhile
+            let found = scala#SanitizeDirForFuzzyFinder(tempfrom) . '/'
+        else
+            let found = from
+        endif
+
+        return found
+    endfunction
+
+    "
+    " GetTestDirForFuzzyFinder()
+    "
+    " Now overload GetDirForFuzzyFinder() specifically for the test directory (I'm
+    " really only interested in going down into test/src 90% of the time, so let's
+    " hit that 90% and leave the other 10% to couple of extra keystrokes)
+    "
+    function! scala#GetTestDirForFuzzyFinder(from)
+        return scala#GetDirForFuzzyFinder(a:from, 'src/test/scala/')
+    endfunction
+
+    "
+    " GetMainDirForFuzzyFinder()
+    "
+    " Now overload GetDirForFuzzyFinder() specifically for the main directory.
+    "
+    function! scala#GetMainDirForFuzzyFinder(from)
+        return scala#GetDirForFuzzyFinder(a:from, 'src/main/scala/')
+    endfunction
+
+    "
+    " GetRootDirForFuzzyFinder()
+    "
+    " Now overload GetDirForFuzzyFinder() specifically for the root directory.
+    "
+    function! scala#GetRootDirForFuzzyFinder(from)
+        return scala#GetDirForFuzzyFinder(a:from, 'src/../')
+    endfunction
+
+    " If you want to disable the default key mappings, write the following line in
+    " your ~/.vimrc
+    "     let g:scala_use_default_keymappings = 0
+    if get(g:, 'scala_use_default_keymappings', 1)
+      nnoremap <buffer> <silent> <Leader>ft :FufFile <c-r>=scala#GetTestDirForFuzzyFinder('%:p:h')<cr><cr>
+      nnoremap <buffer> <silent> <Leader>fs :FufFile <c-r>=scala#GetMainDirForFuzzyFinder('%:p:h')<cr><cr>
+      nnoremap <buffer> <silent> <Leader>fr :FufFile <c-r>=scala#GetRootDirForFuzzyFinder('%:p:h')<cr><cr>
+    endif
+endif
+
+function! s:CreateOrExpression(keywords)
+  return '('.join(a:keywords, '|').')'
+endfunction
+
+function! s:NextSection(backwards)
+  if a:backwards
+    let dir = '?'
+  else
+    let dir = '/'
+  endif
+  let keywords = [ 'def', 'class', 'trait', 'object' ]
+  let keywordsOrExpression = s:CreateOrExpression(keywords)
+
+  let modifiers = [ 'public', 'private', 'private\[\w*\]', 'protected', 'abstract', 'case', 'override', 'implicit', 'final', 'sealed']
+  let modifierOrExpression = s:CreateOrExpression(modifiers)
+
+  let regex = '^ *('.modifierOrExpression.' )* *'.keywordsOrExpression."\r"
+  execute 'silent normal! ' . dir . '\v'.regex
+endfunction
+
+noremap <script> <buffer> <silent> ]] :call <SID>NextSection(0)<cr>
+noremap <script> <buffer> <silent> [[ :call <SID>NextSection(1)<cr>
+
+" vim:set sw=2 sts=2 ts=8 et:

sources_non_forked/vim-scala/ftplugin/scala.xpt.vim

@@ -0,0 +1,29 @@
+
+XPTemplate priority=lang
+
+XPTvar $BRif ' '
+XPTvar $BRel \n
+XPTvar $BRloop ' '
+XPTvar $BRfun ' '
+
+XPTinclude
+    \ _common/personal
+    \ java/java
+
+XPT cake hint=Cake\ Pattern
+XSET trait|def=Some
+XSET derived|def=Real
+trait `trait^Component {
+	trait `trait^ {
+		`body^
+	}
+
+	val `trait^SV('(.)', '\l\1', '')^^: `trait^
+}
+
+trait `derived^`trait^Component extends `trait^Component {
+
+	override lazy val `trait^SV('(.)', '\l\1', '')^^ = new `trait^ {
+		`body2^
+	}
+}

sources_non_forked/vim-scala/ftplugin/scala/tagbar.vim

@@ -0,0 +1,31 @@
+"
+" Support for Tagbar -- https://github.com/majutsushi/tagbar
+"
+" Hat tip to Leonard Ehrenfried for the built-in ctags deffile:
+"    https://leonard.io/blog/2013/04/editing-scala-with-vim/
+"
+if !exists(':Tagbar')
+  finish
+endif
+
+let g:tagbar_type_scala = {
+    \ 'ctagstype' : 'scala',
+    \ 'sro'        : '.',
+    \ 'kinds'     : [
+      \ 'p:packages',
+      \ 'T:types:1',
+      \ 't:traits',
+      \ 'o:objects',
+      \ 'O:case objects',
+      \ 'c:classes',
+      \ 'C:case classes',
+      \ 'm:methods',
+      \ 'V:values:1',
+      \ 'v:variables:1'
+    \ ]
+\ }
+
+" In case you've updated/customized your ~/.ctags and prefer to use it.
+if get(g:, 'scala_use_builtin_tagbar_defs', 1)
+  let g:tagbar_type_scala.deffile = expand('<sfile>:p:h:h:h') . '/ctags/scala.ctags'
+endif

sources_non_forked/vim-scala/indent/README

@@ -0,0 +1,78 @@
+Scala Indent file for Vim
+=========================
+
+You can check 'testfile.scala' in this directory to see what I'm testing
+against.  I'm mostly just trying to fit the major conventions that people would
+code in with Scala, and not all of the possibilities - life's too short for that
+and I'd rather be writing Scala code than Vim indent code.
+
+With that said, if there's something you're passionate about and you want it to
+be properly indented, and you can't hack it in yourself, then feel free to drop
+me a line and we'll fight about it.
+
+You'll see the following comments in 'testfile.scala':
+
+    /**
+     * The following stuff doesn't work, but honestly, it's pretty
+     * pathological stuff... format your code differently.
+     *
+     * ---- 1. ----
+     *
+     *    if (b) 1
+     *    else
+     *      if (c) 2
+     *    else 3
+     *
+     *    Do this instead:
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c) 2
+     *      else 3
+     *    }
+     *    
+     *
+     * ---- 2. ----
+     *
+     *    if (b) 1
+     *    else
+     *      if (c)
+     *        2
+     *        else 3
+     *
+     *    Do this instead:
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c) 2
+     *      else 3
+     *    }
+     *
+     *    or this...
+     *    
+     *    if (b) 1
+     *    else {
+     *      if (c)
+     *        2
+     *      else
+     *        3
+     *    }
+     *
+     * ---- 3. ----
+     *    
+     *    if (b) 1
+     *    else {
+     *      if (c)
+     *        2
+     *        else 3
+     *    }
+     *
+     *    Do the same as in number 2
+     */
+
+In other words, for the forseeable future... do something different to fix the
+cases that don't work. :)
+
+If you've got any questions about what's defined now, you can reach me at
+http://derekwyatt.org.
+

sources_non_forked/vim-scala/indent/scala.vim

@@ -0,0 +1,603 @@
+" Vim indent file
+" Language         : Scala (http://scala-lang.org/)
+" Original Author  : Stefan Matthias Aust
+" Modifications by : Derek Wyatt
+" Last Change: 2011 Mar 19 (Derek Wyatt)
+
+if exists("b:did_indent")
+  finish
+endif
+let b:did_indent = 1
+
+setlocal autoindent
+setlocal indentexpr=GetScalaIndent()
+setlocal indentkeys=0{,0},0),!^F,<>>,o,O,e,=case,<CR>
+
+if exists("*GetScalaIndent")
+  finish
+endif
+
+let s:defMatcher = '\%(\%(private\|protected\)\%(\[[^\]]*\]\)\?\s\+\|abstract\s\+\|override\s\+\)*\<def\>'
+let s:funcNameMatcher = '\w\+'
+let s:typeSpecMatcher = '\%(\s*\[\_[^\]]*\]\)'
+let s:defArgMatcher = '\%((\_.\{-})\)'
+let s:returnTypeMatcher = '\%(:\s*\w\+' . s:typeSpecMatcher . '\?\)'
+let g:fullDefMatcher = '^\s*' . s:defMatcher . '\s\+' . s:funcNameMatcher . '\s*' . s:typeSpecMatcher . '\?\s*' . s:defArgMatcher . '\?\s*' . s:returnTypeMatcher . '\?\s*[={]'
+
+function! scala#ConditionalConfirm(msg)
+  if 0
+    call confirm(a:msg)
+  endif
+endfunction
+
+function! scala#GetLine(lnum)
+  let line = substitute(getline(a:lnum), '//.*$', '', '')
+  let line = substitute(line, '"\(.\|\\"\)\{-}"', '""', 'g')
+  return line
+endfunction
+
+function! scala#CountBrackets(line, openBracket, closedBracket)
+  let line = substitute(a:line, '"\(.\|\\"\)\{-}"', '', 'g')
+  let open = substitute(line, '[^' . a:openBracket . ']', '', 'g')
+  let close = substitute(line, '[^' . a:closedBracket . ']', '', 'g')
+  return strlen(open) - strlen(close)
+endfunction
+
+function! scala#CountParens(line)
+  return scala#CountBrackets(a:line, '(', ')')
+endfunction
+
+function! scala#CountCurlies(line)
+  return scala#CountBrackets(a:line, '{', '}')
+endfunction
+
+function! scala#LineEndsInIncomplete(line)
+  if a:line =~ '[.,]\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineIsAClosingXML(line)
+  if a:line =~ '^\s*</\w'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineCompletesXML(lnum, line)
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], a:lnum, 0, savedpos[3]])
+  let tag = substitute(a:line, '^.*</\([^>]*\)>.*$', '\1', '')
+  let [lineNum, colnum] = searchpairpos('<' . tag . '>', '', '</' . tag . '>', 'Wbn')
+  call setpos('.', savedpos)
+  let pline = scala#GetLine(prevnonblank(lineNum - 1))
+  if pline =~ '=\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#IsParentCase()
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], savedpos[1], 0, savedpos[3]])
+  let [l, c] = searchpos('^\s*\%(' . s:defMatcher . '\|\%(\<case\>\)\)', 'bnW')
+  let retvalue = -1
+  if l != 0 && search('\%' . l . 'l\s*\<case\>', 'bnW')
+    let retvalue = l
+  endif 
+  call setpos('.', savedpos)
+  return retvalue
+endfunction
+
+function! scala#CurlyMatcher()
+  let matchline = scala#GetLineThatMatchesBracket('{', '}')
+  if scala#CountParens(scala#GetLine(matchline)) < 0
+    let savedpos = getpos('.')
+    call setpos('.', [savedpos[0], matchline, 9999, savedpos[3]])
+    call searchpos('{', 'Wbc')
+    call searchpos(')', 'Wb')
+    let [lnum, colnum] = searchpairpos('(', '', ')', 'Wbn')
+    call setpos('.', savedpos)
+    let line = scala#GetLine(lnum)
+    if line =~ '^\s*' . s:defMatcher
+      return lnum
+    else
+      return matchline
+    endif
+  else
+    return matchline
+  endif
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesCurly()
+  return scala#GetLineAndColumnThatMatchesBracket('{', '}')
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesParen()
+  return scala#GetLineAndColumnThatMatchesBracket('(', ')')
+endfunction
+
+function! scala#GetLineAndColumnThatMatchesBracket(openBracket, closedBracket)
+  let savedpos = getpos('.')
+  let curline = scala#GetLine(line('.'))
+  if curline =~ a:closedBracket . '.*' . a:openBracket . '.*' . a:closedBracket
+    call setpos('.', [savedpos[0], savedpos[1], 0, savedpos[3]])
+    call searchpos(a:closedBracket . '\ze[^' . a:closedBracket . a:openBracket . ']*' . a:openBracket, 'W')
+  else
+    call setpos('.', [savedpos[0], savedpos[1], 9999, savedpos[3]])
+    call searchpos(a:closedBracket, 'Wbc')
+  endif
+  let [lnum, colnum] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbn')
+  call setpos('.', savedpos)
+  return [lnum, colnum]
+endfunction
+
+function! scala#GetLineThatMatchesCurly()
+  return scala#GetLineThatMatchesBracket('{', '}')
+endfunction
+
+function! scala#GetLineThatMatchesParen()
+  return scala#GetLineThatMatchesBracket('(', ')')
+endfunction
+
+function! scala#GetLineThatMatchesBracket(openBracket, closedBracket)
+  let [lnum, colnum] = scala#GetLineAndColumnThatMatchesBracket(a:openBracket, a:closedBracket)
+  return lnum
+endfunction
+
+function! scala#NumberOfBraceGroups(line)
+  let line = substitute(a:line, '[^()]', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let line = substitute(line, '^)*', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let line = substitute(line, '^(', '', 'g')
+  if strlen(line) == 0
+    return 0
+  endif
+  let c = 1
+  let counter = 0
+  let groupCount = 0
+  while counter < strlen(line)
+    let char = strpart(line, counter, 1)
+    if char == '('
+      let c = c + 1
+    elseif char == ')'
+      let c = c - 1
+    endif
+    if c == 0
+      let groupCount = groupCount + 1
+    endif
+    let counter = counter + 1
+  endwhile
+  return groupCount
+endfunction
+
+function! scala#MatchesIncompleteDefValr(line)
+  if a:line =~ '^\s*\%(' . s:defMatcher . '\|\<va[lr]\>\).*[=({]\s*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineIsCompleteIf(line)
+  if scala#CountBrackets(a:line, '{', '}') == 0 &&
+   \ scala#CountBrackets(a:line, '(', ')') == 0 &&
+   \ a:line =~ '^\s*\<if\>\s*([^)]*)\s*\S.*$'
+    return 1
+  else
+    return 0
+  endif
+endfunction
+
+function! scala#LineCompletesIfElse(lnum, line)
+  if a:line =~ '^\s*\%(\<if\>\|\%(}\s*\)\?\<else\>\)'
+    return 0
+  endif
+  let result = search('^\%(\s*\<if\>\s*(.*).*\n\|\s*\<if\>\s*(.*)\s*\n.*\n\)\%(\s*\<else\>\s*\<if\>\s*(.*)\s*\n.*\n\)*\%(\s*\<else\>\s*\n\|\s*\<else\>[^{]*\n\)\?\%' . a:lnum . 'l', 'Wbn')
+  if result != 0 && scala#GetLine(prevnonblank(a:lnum - 1)) !~ '{\s*$'
+    return result
+  endif
+  return 0
+endfunction
+
+function! scala#GetPrevCodeLine(lnum)
+  " This needs to skip comment lines
+  return prevnonblank(a:lnum - 1)
+endfunction
+
+function! scala#InvertBracketType(openBracket, closedBracket)
+  if a:openBracket == '('
+    return [ '{', '}' ]
+  else
+    return [ '(', ')' ]
+  endif
+endfunction
+
+function! scala#Testhelper(lnum, line, openBracket, closedBracket, iteration)
+  let bracketCount = scala#CountBrackets(a:line, a:openBracket, a:closedBracket)
+  " There are more '}' braces than '{' on this line so it may be completing the function definition
+  if bracketCount < 0
+    let [matchedLNum, matchedColNum] = scala#GetLineAndColumnThatMatchesBracket(a:openBracket, a:closedBracket)
+    if matchedLNum == a:lnum
+      return -1
+    endif
+    let matchedLine = scala#GetLine(matchedLNum)
+    if ! scala#MatchesIncompleteDefValr(matchedLine)
+      let bracketLine = substitute(substitute(matchedLine, '\%' . matchedColNum . 'c.*$', '', ''), '[^{}()]', '', 'g')
+      if bracketLine =~ '}$'
+        return scala#Testhelper(matchedLNum, matchedLine, '{', '}', a:iteration + 1)
+      elseif bracketLine =~ ')$'
+        return scala#Testhelper(matchedLNum, matchedLine, '(', ')', a:iteration + 1)
+      else
+        let prevCodeLNum = scala#GetPrevCodeLine(matchedLNum)
+        if scala#MatchesIncompleteDefValr(scala#GetLine(prevCodeLNum))
+          return prevCodeLNum
+        else
+          return -1
+        endif
+      endif
+    else
+      " return indent value instead
+      return matchedLNum
+    endif
+  " There's an equal number of '{' and '}' on this line so it may be a single line function definition
+  elseif bracketCount == 0
+    if a:iteration == 0
+      let otherBracketType = scala#InvertBracketType(a:openBracket, a:closedBracket)
+      return scala#Testhelper(a:lnum, a:line, otherBracketType[0], otherBracketType[1], a:iteration + 1)
+    else
+      let prevCodeLNum = scala#GetPrevCodeLine(a:lnum)
+      let prevCodeLine = scala#GetLine(prevCodeLNum)
+      if scala#MatchesIncompleteDefValr(prevCodeLine) && prevCodeLine !~ '{\s*$'
+        return prevCodeLNum
+      else
+        let possibleIfElse = scala#LineCompletesIfElse(a:lnum, a:line)
+        if possibleIfElse != 0
+          let defValrLine = prevnonblank(possibleIfElse - 1)
+          let possibleDefValr = scala#GetLine(defValrLine)
+          if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+            return possibleDefValr
+          else
+            return -1
+          endif
+        else
+          return -1
+        endif
+      endif
+    endif
+  else
+    return -1
+  endif
+endfunction
+
+function! scala#Test(lnum, line, openBracket, closedBracket)
+  return scala#Testhelper(a:lnum, a:line, a:openBracket, a:closedBracket, 0)
+endfunction
+
+function! scala#LineCompletesDefValr(lnum, line)
+  let bracketCount = scala#CountBrackets(a:line, '{', '}')
+  if bracketCount < 0
+    let matchedBracket = scala#GetLineThatMatchesBracket('{', '}')
+    if ! scala#MatchesIncompleteDefValr(scala#GetLine(matchedBracket))
+      let possibleDefValr = scala#GetLine(prevnonblank(matchedBracket - 1))
+      if matchedBracket != -1 && scala#MatchesIncompleteDefValr(possibleDefValr)
+        return 1
+      else
+        return 0
+      endif
+    else
+      return 0
+    endif
+  elseif bracketCount == 0
+    let bracketCount = scala#CountBrackets(a:line, '(', ')')
+    if bracketCount < 0
+      let matchedBracket = scala#GetLineThatMatchesBracket('(', ')')
+      if ! scala#MatchesIncompleteDefValr(scala#GetLine(matchedBracket))
+        let possibleDefValr = scala#GetLine(prevnonblank(matchedBracket - 1))
+        if matchedBracket != -1 && scala#MatchesIncompleteDefValr(possibleDefValr)
+          return 1
+        else
+          return 0
+        endif
+      else
+        return 0
+      endif
+    elseif bracketCount == 0
+      let possibleDefValr = scala#GetLine(prevnonblank(a:lnum - 1))
+      if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+        return 1
+      else
+        let possibleIfElse = scala#LineCompletesIfElse(a:lnum, a:line)
+        if possibleIfElse != 0
+          let possibleDefValr = scala#GetLine(prevnonblank(possibleIfElse - 1))
+          if scala#MatchesIncompleteDefValr(possibleDefValr) && possibleDefValr =~ '^.*=\s*$'
+            return 2
+          else
+            return 0
+          endif
+        else
+          return 0
+        endif
+      endif
+    else
+      return 0
+    endif
+  endif
+endfunction
+
+function! scala#SpecificLineCompletesBrackets(lnum, openBracket, closedBracket)
+  let savedpos = getpos('.')
+  call setpos('.', [savedpos[0], a:lnum, 9999, savedpos[3]])
+  let retv = scala#LineCompletesBrackets(a:openBracket, a:closedBracket)
+  call setpos('.', savedpos)
+
+  return retv
+endfunction
+
+function! scala#LineCompletesBrackets(openBracket, closedBracket)
+  let savedpos = getpos('.')
+  let offline = 0
+  while offline == 0
+    let [lnum, colnum] = searchpos(a:closedBracket, 'Wb')
+    let [lnumA, colnumA] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbn')
+    if lnum != lnumA
+      let [lnumB, colnumB] = searchpairpos(a:openBracket, '', a:closedBracket, 'Wbnr')
+      let offline = 1
+    endif
+  endwhile
+  call setpos('.', savedpos)
+  if lnumA == lnumB && colnumA == colnumB
+    return lnumA
+  else
+    return -1
+  endif
+endfunction
+
+function! GetScalaIndent()
+  " Find a non-blank line above the current line.
+  let prevlnum = prevnonblank(v:lnum - 1)
+
+  " Hit the start of the file, use zero indent.
+  if prevlnum == 0
+    return 0
+  endif
+
+  let ind = indent(prevlnum)
+  let originalIndentValue = ind
+  let prevline = scala#GetLine(prevlnum)
+  let curlnum = v:lnum
+  let curline = scala#GetLine(curlnum)
+  if get(g:, 'scala_scaladoc_indent', 0)
+    let star_indent = 2
+  else
+    let star_indent = 1
+  end
+
+  if prevline =~ '^\s*/\*\*'
+    if prevline =~ '\*/\s*$'
+      return ind
+    else
+      return ind + star_indent
+    endif
+  endif
+
+  if curline =~ '^\s*\*'
+    return cindent(curlnum)
+  endif
+
+  " If this line starts with a { then make it indent the same as the previous line
+  if curline =~ '^\s*{'
+    call scala#ConditionalConfirm("1")
+    " Unless, of course, the previous one is a { as well
+    if prevline !~ '^\s*{'
+      call scala#ConditionalConfirm("2")
+      return indent(prevlnum)
+    endif
+  endif
+
+  " '.' continuations
+  if curline =~ '^\s*\.'
+    if prevline =~ '^\s*\.'
+      return ind
+    else
+      return ind + &shiftwidth
+    endif
+  endif
+
+  " Indent html literals
+  if prevline !~ '/>\s*$' && prevline =~ '^\s*<[a-zA-Z][^>]*>\s*$'
+    call scala#ConditionalConfirm("3")
+    return ind + &shiftwidth
+  endif
+
+  " assumes curly braces around try-block
+  if curline =~ '^\s*}\s*\<catch\>'
+    return ind - &shiftwidth
+  elseif curline =~ '^\s*\<catch\>'
+    return ind
+  endif
+
+  " Add a 'shiftwidth' after lines that start a block
+  " If 'if', 'for' or 'while' end with ), this is a one-line block
+  " If 'val', 'var', 'def' end with =, this is a one-line block
+  if (prevline =~ '^\s*\<\%(\%(}\?\s*else\s\+\)\?if\|for\|while\)\>.*[)=]\s*$' && scala#NumberOfBraceGroups(prevline) <= 1)
+        \ || prevline =~ '^\s*' . s:defMatcher . '.*=\s*$'
+        \ || prevline =~ '^\s*\<va[lr]\>.*[=]\s*$'
+        \ || prevline =~ '^\s*\%(}\s*\)\?\<else\>\s*$'
+        \ || prevline =~ '=\s*$'
+    call scala#ConditionalConfirm("4")
+    let ind = ind + &shiftwidth
+  elseif prevline =~ '^\s*\<\%(}\?\s*else\s\+\)\?if\>' && curline =~ '^\s*}\?\s*\<else\>'
+    return ind
+  endif
+
+  let lineCompletedBrackets = 0
+  let bracketCount = scala#CountBrackets(prevline, '{', '}')
+  if bracketCount > 0 || prevline =~ '.*{\s*$'
+    call scala#ConditionalConfirm("5b")
+    let ind = ind + &shiftwidth
+  elseif bracketCount < 0
+    call scala#ConditionalConfirm("6b")
+    " if the closing brace actually completes the braces entirely, then we
+    " have to indent to line that started the whole thing
+    let completeLine = scala#LineCompletesBrackets('{', '}')
+    if completeLine != -1
+      call scala#ConditionalConfirm("8b")
+      let prevCompleteLine = scala#GetLine(prevnonblank(completeLine - 1))
+      " However, what actually started this part looks like it was a function
+      " definition, so we need to indent to that line instead.  This is 
+      " actually pretty weak at the moment.
+      if prevCompleteLine =~ '=\s*$'
+        call scala#ConditionalConfirm("9b")
+        let ind = indent(prevnonblank(completeLine - 1))
+      else
+        call scala#ConditionalConfirm("10b")
+        let ind = indent(completeLine)
+      endif
+    else
+      let lineCompletedBrackets = 1
+    endif
+  endif
+
+  if ind == originalIndentValue
+    let bracketCount = scala#CountBrackets(prevline, '(', ')')
+    if bracketCount > 0 || prevline =~ '.*(\s*$'
+      call scala#ConditionalConfirm("5a")
+      let ind = ind + &shiftwidth
+    elseif bracketCount < 0
+      call scala#ConditionalConfirm("6a")
+      " if the closing brace actually completes the braces entirely, then we
+      " have to indent to line that started the whole thing
+      let completeLine = scala#LineCompletesBrackets('(', ')')
+      if completeLine != -1 && prevline !~ '^.*{\s*$'
+        call scala#ConditionalConfirm("8a")
+        let prevCompleteLine = scala#GetLine(prevnonblank(completeLine - 1))
+        " However, what actually started this part looks like it was a function
+        " definition, so we need to indent to that line instead.  This is 
+        " actually pretty weak at the moment.
+        if prevCompleteLine =~ '=\s*$'
+          call scala#ConditionalConfirm("9a")
+          let ind = indent(prevnonblank(completeLine - 1))
+        else
+          call scala#ConditionalConfirm("10a")
+          let ind = indent(completeLine)
+        endif
+      else
+        " This is the only part that's different from from the '{', '}' one below
+        " Yup... some refactoring is necessary at some point.
+        let ind = ind + (bracketCount * &shiftwidth)
+        let lineCompletedBrackets = 1
+      endif
+    endif
+  endif
+
+  if curline =~ '^\s*}\?\s*\<else\>\%(\s\+\<if\>\s*(.*)\)\?\s*{\?\s*$' &&
+   \ ! scala#LineIsCompleteIf(prevline) &&
+   \ prevline !~ '^.*}\s*$'
+    let ind = ind - &shiftwidth
+  endif
+
+  " Subtract a 'shiftwidth' on '}' or html
+  let curCurlyCount = scala#CountCurlies(curline)
+  if curCurlyCount < 0
+    call scala#ConditionalConfirm("14a")
+    let matchline = scala#CurlyMatcher()
+    return indent(matchline)
+  elseif curline =~ '^\s*</[a-zA-Z][^>]*>'
+    call scala#ConditionalConfirm("14c")
+    return ind - &shiftwidth
+  endif
+
+  let prevParenCount = scala#CountParens(prevline)
+  if prevline =~ '^\s*\<for\>.*$' && prevParenCount > 0
+    call scala#ConditionalConfirm("15")
+    let ind = indent(prevlnum) + 5
+  endif
+
+  let prevCurlyCount = scala#CountCurlies(prevline)
+  if prevCurlyCount == 0 && prevline =~ '^.*\%(=>\|⇒\)\s*$' && prevline !~ '^\s*this\s*:.*\%(=>\|⇒\)\s*$' && curline !~ '^\s*\<case\>'
+    call scala#ConditionalConfirm("16")
+    let ind = ind + &shiftwidth
+  endif
+
+  if ind == originalIndentValue && curline =~ '^\s*\<case\>'
+    call scala#ConditionalConfirm("17")
+    let parentCase = scala#IsParentCase()
+    if parentCase != -1
+      call scala#ConditionalConfirm("17a")
+      return indent(parentCase)
+    endif
+  endif
+
+  if prevline =~ '^\s*\*/'
+   \ || prevline =~ '*/\s*$'
+    call scala#ConditionalConfirm("18")
+    let ind = ind - star_indent
+  endif
+
+  if scala#LineEndsInIncomplete(prevline)
+    call scala#ConditionalConfirm("19")
+    return ind
+  endif
+
+  if scala#LineIsAClosingXML(prevline)
+    if scala#LineCompletesXML(prevlnum, prevline)
+      call scala#ConditionalConfirm("20a")
+      return ind - &shiftwidth
+    else
+      call scala#ConditionalConfirm("20b")
+      return ind
+    endif
+  endif
+
+  if ind == originalIndentValue
+    "let indentMultiplier = scala#LineCompletesDefValr(prevlnum, prevline)
+    "if indentMultiplier != 0
+    "  call scala#ConditionalConfirm("19a")
+    "  let ind = ind - (indentMultiplier * &shiftwidth)
+    let defValrLine = scala#Test(prevlnum, prevline, '{', '}')
+    if defValrLine != -1
+      call scala#ConditionalConfirm("21a")
+      let ind = indent(defValrLine)
+    elseif lineCompletedBrackets == 0
+      call scala#ConditionalConfirm("21b")
+      if scala#GetLine(prevnonblank(prevlnum - 1)) =~ '^.*\<else\>\s*\%(//.*\)\?$'
+        call scala#ConditionalConfirm("21c")
+        let ind = ind - &shiftwidth
+      elseif scala#LineCompletesIfElse(prevlnum, prevline)
+        call scala#ConditionalConfirm("21d")
+        let ind = ind - &shiftwidth
+      elseif scala#CountParens(curline) < 0 && curline =~ '^\s*)' && scala#GetLine(scala#GetLineThatMatchesBracket('(', ')')) =~ '.*(\s*$'
+        " Handles situations that look like this:
+        " 
+        "   val a = func(
+        "     10
+        "   )
+        "
+        " or
+        "
+        "   val a = func(
+        "     10
+        "   ).somethingHere()
+        call scala#ConditionalConfirm("21e")
+        let ind = ind - &shiftwidth
+      endif
+    endif
+  endif
+
+  call scala#ConditionalConfirm("returning " . ind)
+
+  return ind
+endfunction
+
+" vim:set sw=2 sts=2 ts=8 et:
+" vim600:fdm=marker fdl=1 fdc=0:

sources_non_forked/vim-scala/indent/testfile.scala

@@ -0,0 +1,387 @@
+/**
+ * Comments are here
+ */
+class SomeClass {
+  val someval = SomeObject.makeWithSomething
+  var somevar = SomeObject.makeWithSomething
+
+  def someBracedDef = {
+    case ASingleLineCase => a.statement
+
+    case AMultiLineCase =>
+      if (this)
+        then
+      else
+        that
+  }
+
+  def aSingleLineDef = someval + 12
+
+  def main(args: Array[String]) = run(20000, 20000)
+
+  def multilineParams(
+    x: Int,
+    y: Int
+  ) = {
+    ???
+  }
+
+  // This
+  def aMultiLineSingleStatementDefWithBraces = {
+    SomeObject.makeWithSomething
+  }
+
+  // This
+  def aMultiLineSingleStatementDefWithNoBraces =
+    new X {
+      def something = 5
+    }
+
+  def aMultiLineSingleStatementDefWithNoBraces =
+    SomeObject.makeWithSomething
+
+  def someFunc = {
+    if (b) 1
+    else {
+      if (b) 2
+      else
+        3
+    }
+  }
+
+  def someOtherFunc =
+    if (this)
+      that
+    else
+      theOther
+
+  def someOtherOtherFunc = {
+    if (b) 1
+    else {
+      if (b) 2
+      else
+        3
+    }
+
+    /**
+     * The following stuff doesn't work, but honestly, it's pretty
+     * pathological stuff... format your code differently.
+     *
+     * ---- 1. ----
+     *
+     *    if (b) 1
+     *    else
+     *      if (c) 2
+     *    else 3 // Should be the same as the above 'if'
+     *
+     *    Do this instead:
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c) 2
+     *      else 3
+     *    }
+     *
+     *
+     * ---- 2. ----
+     *
+     *    if (b) 1
+     *    else
+     *      if (c)
+     *        2
+     *        else 3
+     *
+     *    Do this instead:
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c) 2
+     *      else 3
+     *    }
+     *
+     *    or this...
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c)
+     *        2
+     *      else
+     *        3
+     *    }
+     *
+     * ---- 3. ----
+     *
+     *    if (b) 1
+     *    else {
+     *      if (c)
+     *        2
+     *        else 3
+     *    }
+     *
+     *    Do the same as in number 2
+     */
+
+    if (b) {
+      statement
+    }
+    else
+      thing
+
+    if (b)
+      statement
+
+    bare_statement
+
+    if (b) {
+      statement
+    }
+    else {
+      thing
+      that
+    }
+
+    if (statement(nested statement(another nested statement))) func(statement)
+    if (statement(nested statement(another nested statement))) statement
+
+    if (b) {
+      statement
+      statement
+    } else if (b) {
+      statement
+      statement
+    } else if (c) {
+      statement
+      statement
+    } else
+      dohicky
+
+    if (b) { // comment
+      statement
+      statement
+    } else if (b) { // comment
+      statement
+      statement
+    } else if (c) { // comment
+      statement
+      statement
+    } else // comment
+      dohicky
+
+    if (b)
+      statement
+    else {
+      statement
+      statement
+    }
+
+    val a = if (b) {
+      10
+    } else { statement }
+
+    val a = func(
+      10
+    ).goThere()
+
+    val a = func(
+      10
+    )
+
+    if (b) (statement)
+    else 2
+
+    if (b) 1
+    else 2
+
+    if (b)
+      1
+    else if (b)
+      2
+    else if (b)
+      2
+    else
+      3
+    4
+
+    if (b)
+      1
+    else if (b)
+      2
+    else
+      3
+    4
+  }
+
+  /**
+   * This
+   */
+  def SomeOtherFunc = ...
+
+  /** This */
+  def blah = ...
+
+  def func = {
+    val reply = new Something()
+    some.block {
+      def foo("string", bar("string"))
+      new X {
+        statement
+        statement
+      }
+    }
+    () => goAndDo.something
+  }
+
+  def func(param: Int) = new this.Something.Or.Other(
+    new SillyObject {
+      override def booger() = {
+        statement
+        statement
+      }
+    },
+    otherParam) // comment
+
+  class AnotherSomeClass {
+    this: Actor =>
+    def func = {
+      booger
+    }
+  }
+
+  /**
+   * Pulled this stuff from the fors.scala example file in the source distribution
+   */
+  def findNums(n: Int): Iterable[(Int, Int)] =
+    for (i <- 1 until n;
+         j <- 1 until (i-1);
+         if isPrime(i+j)) yield (i, j)
+
+  val books = List(
+    Elem(prefix, "book", e, scope,
+      Elem(prefix, "title", e, scope,
+        Text("Structure and Interpretation of Computer Programs")),
+      Elem(prefix, "author", e, scope,
+        Text("Abelson, Harald")),
+      Elem(prefix, "author", e, scope,
+        Text("Sussman, Gerald J."))),
+    Elem(prefix, "book", e, scope,
+      Elem(prefix, "title", e, scope,
+        Text("Principles of Compiler Design")),
+      Elem(prefix, "author", e, scope,
+        Text("Aho, Alfred")),
+      Elem(prefix, "author", e, scope,
+        Text("Ullman, Jeffrey"))),
+    Elem(prefix, "book", e, scope,
+      Elem(prefix, "title", e, scope,
+        Text("Programming in Modula-2")),
+      Elem(prefix, "author", e, scope,
+        Text("Wirth, Niklaus")))
+    )
+
+  def mufync(statement): Int = {
+    val x = function(thing)
+    if (statement) func(statement)
+    else func(statement)
+  }
+
+  def SomeOtherFunc = statement
+
+  def receive = {
+    case Something =>
+    case OrOther =>
+      here
+    case There =>
+  }
+
+  def func[A <: B](one: One, two: Two) : ReturnType = ...
+  def func(one: One, two: Two) : ReturnType = ...
+  def func(one: (A, B) => B) : ReturnType = ...
+  def func(one: One, two: Two) = ...
+  def func(one: One, two: Two) = ...
+  def func[A <: B](one: One,
+    two: Two) : ReturnType = ...
+  def func(one: One, two: Two, three: Three, four: Four,
+    five: Five) : ReturnType = ...
+  def func(one: One, two: Two, three: Three, four: Four,
+    five: Five) = ...
+
+  def func = oneliner
+  private def func = oneliner
+  private[thing] def func = oneliner
+  protected def func = oneliner
+  protected[thing] def func = oneliner
+  override def func = oneliner
+  abstract override def func = oneliner
+  override abstract def func = oneliner
+  protected override def func = oneliner
+  protected abstract override def func = oneliner
+  protected override abstract def func = oneliner
+  protected[thing] override def func = oneliner
+  protected[thing] abstract override def func = oneliner
+  protected[thing] override abstract def func = oneliner
+  private override def func = oneliner
+  private abstract override def func = oneliner
+  private override abstract def func = oneliner
+  private[thing] override def func = oneliner
+  private[thing] abstract override def func = oneliner
+  private[thing] override abstract def func = oneliner
+
+  <outertag>
+    <innertag>
+      <in-innertag>
+        Something
+      </in-innertag>
+    </innertag>
+  </outertag>
+
+  val someXML =
+    <outertag>
+      <innertag>
+        <in-innertag>
+          Something
+        </in-innertag>
+      </innertag>
+    </outertag>
+
+  private[somepackage] abstract override def somethingWithDots = {
+    SomeObject.build
+      .withSomething
+      .withSomethingElse
+      .withSomethingElseAgain
+  }
+
+  private def oneLineFunc = actorOf(new Actor {
+    def receive = {
+      case _ => thing
+    }
+  })
+
+  private def oneLineFunc = factory(
+    arg1,
+    arg2,
+    arg3).build
+
+  def someFunction[T <: U](
+    x: Int): SomeType = {
+      val someValue: Option[Int] = {
+        someValue match {
+          some stuff here
+        }
+      }
+  }
+
+  def someFunction[T <: U](
+    x: Int,
+    y: Int,
+    z: Long): SomeType = {
+      val someValue: Option[Int] = {
+        someValue match {
+          some stuff here
+        }
+      }
+  }
+
+  private[this] def followingFunction = oneliner
+
+  val someFunction: List[(Option[T], Option[U])] = TODO
+}
+

sources_non_forked/vim-scala/plugin/scala.vim

@@ -0,0 +1,149 @@
+" Vim plugin file
+" Language:             Scala
+" Maintainer:           Derek Wyatt
+" URL:                  https://github.com/derekwyatt/vim-scala
+" License:              Apache 2
+" ----------------------------------------------------------------------------
+
+if exists('g:loaded_scala') || &cp
+  finish
+endif
+let g:loaded_scala = 1
+
+"
+" Sort imports
+"
+" author: Leonard Ehrenfried <leonard.ehrenfried@gmail.com>
+"
+function! SortScalaImports()
+  let save_cursor = getpos(".")
+
+  if exists('g:scala_sort_across_groups') && g:scala_sort_across_groups
+    call s:sortAcrossGroups()
+  else
+    call s:sortInsideGroups()
+  end
+
+  "move cursor to where it was before the function call
+  call setpos('.', save_cursor)
+
+endfunction
+
+" Iterates over _all_ imports and puts them into 3 groups
+"
+" 1. Java/Scala imports like java.util.UUID
+" 2. Third party libraries
+" 3. First party libraries (ie. your own stuff)
+"
+function! s:sortAcrossGroups()
+  let curr = 1
+  let first_line = -1
+  let last_line = -1
+  let trailing_newlines = 0
+  let java_scala_imports = []
+  let first_party_imports = []
+  let third_party_imports = []
+
+  " loop over lines in buffer
+  while curr <= line('$')
+
+    let line = getline(curr)
+
+    if line =~ "^import"
+      if first_line == -1
+        let first_line = curr
+      endif
+
+      if line =~ '^import \(java\(x\)\?\|scala\)\.'
+        call add(java_scala_imports, line)
+      elseif exists('g:scala_first_party_namespaces')
+        let regex = '^import '.g:scala_first_party_namespaces
+        if line =~ regex
+          call add(first_party_imports, line)
+        else
+          call add(third_party_imports, line)
+        endif
+      else
+        call add(third_party_imports, line)
+      endif
+
+      let trailing_newlines = 0
+    elseif empty(line)
+      let trailing_newlines = trailing_newlines + 1
+    elseif first_line != -1
+      let last_line = curr - trailing_newlines - 1
+      " break out when you have found the first non-import, non-empty line
+      break
+    endif
+
+    let curr = curr + 1
+  endwhile
+
+  call cursor(first_line, 0)
+  let to_delete = last_line - first_line
+
+  if to_delete > 0
+    execute 'd'to_delete
+  endif
+
+  call s:sortAndPrint(first_party_imports)
+  call s:sortAndPrint(third_party_imports)
+  call s:sortAndPrint(java_scala_imports)
+
+  if first_line != -1
+    " remove extra blank line at top
+    execute 'delete'
+  endif
+
+  call cursor(last_line + 2, 0)
+  if empty(getline(line(".")))
+    execute 'delete'
+  endif
+
+endfunction
+
+function! s:sortInsideGroups()
+  call cursor(1, 1)
+
+  let start = 1
+  let end = 1
+
+  " repeat until we find no more matches
+  while(start > 0 && end > 0)
+    let pos = line(".")
+    " find first line with import
+    let start = search('^import', 'cW')
+    " find next line which starts with an import, ends with a newline
+    " and the next line is not an import
+    " the 'c' flag accepts matches at the current position allowing single line groups
+    let end = search('^\import.*\n\(import\)\@!', 'cW')
+
+    execute start','end'sort i'
+
+    call cursor(end + 1, 0)
+
+    " stop if end is the last line in the file
+    if line("$") == end
+      break
+    endif
+
+  endwhile
+endfunction
+
+function! s:sortAndPrint(imports)
+  if len(a:imports) > 0
+    call sort(a:imports, "s:sortIgnoreCase")
+    call append(line("."), "")
+    call append(line("."), a:imports)
+  endif
+endfunction
+
+" this useless function exists purely so the sort() ignores case
+" this is needed so scalaz/Scalaz appears next to each other
+function! s:sortIgnoreCase(i1, i2)
+  return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
+endfunction
+
+command! SortScalaImports call SortScalaImports()
+
+" vim:set sw=2 sts=2 ts=8 et:

sources_non_forked/vim-scala/spec/fixtures/multiple_newlines.expected.scala

@@ -0,0 +1,11 @@
+package com.foo
+
+import java.bla
+import scala.horst
+
+import AgentTypes._
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/multiple_newlines.scala

@@ -0,0 +1,12 @@
+package com.foo
+
+import AgentTypes._
+import scala.horst
+
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+
+import java.bla
+
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_newline.expected.scala

@@ -0,0 +1,9 @@
+package com.foo
+
+import java.bla
+import scala.horst
+
+import AgentTypes._
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_newline.scala

@@ -0,0 +1,8 @@
+package com.foo
+
+import java.bla
+import AgentTypes._
+import scala.horst
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_newline_after.expected.scala

@@ -0,0 +1,8 @@
+package com.foo
+
+import java.bla
+import scala.horst
+
+import AgentTypes._
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_newline_after.scala

@@ -0,0 +1,7 @@
+package com.foo
+
+import java.bla
+import AgentTypes._
+import scala.horst
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_package.expected.scala

@@ -0,0 +1,7 @@
+import java.bla
+import scala.horst
+
+import AgentTypes._
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/no_package.scala

@@ -0,0 +1,6 @@
+import java.bla
+import AgentTypes._
+import scala.horst
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/vanilla.expected.scala

@@ -0,0 +1,9 @@
+package com.foo
+
+import java.bla
+import scala.horst
+
+import AgentTypes._
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/fixtures/vanilla.scala

@@ -0,0 +1,9 @@
+package com.foo
+
+import java.bla
+import AgentTypes._
+import scala.horst
+
+import akka.actor.{Actor, ActorLogging, ActorRef, ActorRefFactory, ActorSystem, Props, Stash, Terminated}
+
+class Bar

sources_non_forked/vim-scala/spec/import_sorting_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe ":SortScalaImports" do
+
+  describe "Sorting across groups" do
+    ["vanilla", "no_newline", "no_newline_after", "no_package",
+     "multiple_newlines"].each do |name|
+      it "should sort vanilla file" do
+        actual = sort_fixture_across_groups name
+        expected = expected(name)
+        actual.should eq(expected)
+      end
+    end
+  end
+
+end

sources_non_forked/vim-scala/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'vimrunner'
+require 'tempfile'
+
+PWD = File.expand_path File.dirname(__FILE__)
+
+RSpec.configure do |config|
+
+  config.before(:suite) do
+    VIM = Vimrunner.start
+    VIM.add_plugin(File.expand_path('../..', __FILE__), 'plugin/scala.vim')
+  end
+
+  config.after(:suite) do
+    VIM.kill
+  end
+end
+
+def sort_fixture_across_groups(name)
+  fixture_path = "#{PWD}/fixtures/#{name}.scala"
+
+  temp_file = Tempfile.new('vim-scala-')
+  temp_file.write File.read(fixture_path)
+  temp_file.rewind
+
+  VIM.edit temp_file.path
+
+  VIM.command "let g:scala_sort_across_groups=1"
+  VIM.command "SortScalaImports"
+  VIM.write
+
+  temp_file.rewind
+  output = temp_file.read
+
+  temp_file.close
+  temp_file.unlink
+
+  output
+end
+
+def expected(name)
+  path = "#{PWD}/fixtures/#{name}.expected.scala"
+  File.read(path)
+end
+

sources_non_forked/vim-scala/syntax/scala.vim

@@ -0,0 +1,230 @@
+" Vim syntax file
+" Language:             Scala
+" Maintainer:           Derek Wyatt
+" URL:                  https://github.com/derekwyatt/vim-scala
+" License:              Apache 2
+" ----------------------------------------------------------------------------
+
+if !exists('main_syntax')
+  if version < 600
+    syntax clear
+  elseif exists("b:current_syntax")
+    finish
+  endif
+  let main_syntax = 'scala'
+endif
+
+scriptencoding utf-8
+
+let b:current_syntax = "scala"
+
+" Allows for embedding, see #59; main_syntax convention instead? Refactor TOP
+"
+" The @Spell here is a weird hack, it means *exclude* if the first group is
+" TOP. Otherwise we get spelling errors highlighted on code elements that
+" match scalaBlock, even with `syn spell notoplevel`.
+function! s:ContainedGroup()
+  try
+    silent syn list @scala
+    return '@scala,@NoSpell'
+  catch /E392/
+    return 'TOP,@Spell'
+  endtry
+endfunction
+
+unlet! b:current_syntax
+
+syn case match
+syn sync minlines=200 maxlines=1000
+
+syn keyword scalaKeyword catch do else final finally for forSome if
+syn keyword scalaKeyword match return throw try while yield macro
+syn keyword scalaKeyword class trait object extends with nextgroup=scalaInstanceDeclaration skipwhite
+syn keyword scalaKeyword case nextgroup=scalaKeyword,scalaCaseFollowing skipwhite
+syn keyword scalaKeyword val nextgroup=scalaNameDefinition,scalaQuasiQuotes skipwhite
+syn keyword scalaKeyword def var nextgroup=scalaNameDefinition skipwhite
+hi link scalaKeyword Keyword
+
+exe 'syn region scalaBlock start=/{/ end=/}/ contains=' . s:ContainedGroup() . ' fold'
+
+syn keyword scalaAkkaSpecialWord when goto using startWith initialize onTransition stay become unbecome
+hi link scalaAkkaSpecialWord PreProc
+
+syn keyword scalatestSpecialWord shouldBe
+syn match scalatestShouldDSLA /^\s\+\zsit should/
+syn match scalatestShouldDSLB /\<should\>/
+hi link scalatestSpecialWord PreProc
+hi link scalatestShouldDSLA PreProc
+hi link scalatestShouldDSLB PreProc
+
+syn match scalaSymbol /'[_A-Za-z0-9$]\+/
+hi link scalaSymbol Number
+
+syn match scalaChar /'.'/
+syn match scalaChar /'\\[\\"'ntbrf]'/ contains=scalaEscapedChar
+syn match scalaChar /'\\u[A-Fa-f0-9]\{4}'/ contains=scalaUnicodeChar
+syn match scalaEscapedChar /\\[\\"'ntbrf]/
+syn match scalaUnicodeChar /\\u[A-Fa-f0-9]\{4}/
+hi link scalaChar Character
+hi link scalaEscapedChar Function
+hi link scalaUnicodeChar Special
+
+syn match scalaOperator "||"
+syn match scalaOperator "&&"
+hi link scalaOperator Special
+
+syn match scalaNameDefinition /\<[_A-Za-z0-9$]\+\>/ contained nextgroup=scalaPostNameDefinition,scalaVariableDeclarationList
+syn match scalaNameDefinition /`[^`]\+`/ contained nextgroup=scalaPostNameDefinition
+syn match scalaVariableDeclarationList /\s*,\s*/ contained nextgroup=scalaNameDefinition
+syn match scalaPostNameDefinition /\_s*:\_s*/ contained nextgroup=scalaTypeDeclaration
+hi link scalaNameDefinition Function
+
+syn match scalaInstanceDeclaration /\<[_\.A-Za-z0-9$]\+\>/ contained nextgroup=scalaInstanceHash
+syn match scalaInstanceDeclaration /`[^`]\+`/ contained
+syn match scalaInstanceHash /#/ contained nextgroup=scalaInstanceDeclaration
+hi link scalaInstanceDeclaration Special
+hi link scalaInstanceHash Type
+
+syn match scalaUnimplemented /???/
+hi link scalaUnimplemented ERROR
+
+syn match scalaCapitalWord /\<[A-Z][A-Za-z0-9$]*\>/
+hi link scalaCapitalWord Special
+
+" Handle type declarations specially
+syn region scalaTypeStatement matchgroup=Keyword start=/\<type\_s\+\ze/ end=/$/ contains=scalaTypeTypeDeclaration,scalaSquareBrackets,scalaTypeTypeEquals,scalaTypeStatement
+
+" Ugh... duplication of all the scalaType* stuff to handle special highlighting
+" of `type X =` declarations
+syn match scalaTypeTypeDeclaration /(/ contained nextgroup=scalaTypeTypeExtension,scalaTypeTypeEquals contains=scalaRoundBrackets skipwhite
+syn match scalaTypeTypeDeclaration /\%(⇒\|=>\)\ze/ contained nextgroup=scalaTypeTypeDeclaration contains=scalaTypeTypeExtension skipwhite
+syn match scalaTypeTypeDeclaration /\<[_\.A-Za-z0-9$]\+\>/ contained nextgroup=scalaTypeTypeExtension,scalaTypeTypeEquals skipwhite
+syn match scalaTypeTypeEquals /=\ze[^>]/ contained nextgroup=scalaTypeTypePostDeclaration skipwhite
+syn match scalaTypeTypeExtension /)\?\_s*\zs\%(⇒\|=>\|<:\|:>\|=:=\|::\|#\)/ contained nextgroup=scalaTypeTypeDeclaration skipwhite
+syn match scalaTypeTypePostDeclaration /\<[_\.A-Za-z0-9$]\+\>/ contained nextgroup=scalaTypeTypePostExtension skipwhite
+syn match scalaTypeTypePostExtension /\%(⇒\|=>\|<:\|:>\|=:=\|::\)/ contained nextgroup=scalaTypeTypePostDeclaration skipwhite
+hi link scalaTypeTypeDeclaration Type
+hi link scalaTypeTypeExtension Keyword
+hi link scalaTypeTypePostDeclaration Special
+hi link scalaTypeTypePostExtension Keyword
+
+syn match scalaTypeDeclaration /(/ contained nextgroup=scalaTypeExtension contains=scalaRoundBrackets skipwhite
+syn match scalaTypeDeclaration /\%(⇒\|=>\)\ze/ contained nextgroup=scalaTypeDeclaration contains=scalaTypeExtension skipwhite
+syn match scalaTypeDeclaration /\<[_\.A-Za-z0-9$]\+\>/ contained nextgroup=scalaTypeExtension skipwhite
+syn match scalaTypeExtension /)\?\_s*\zs\%(⇒\|=>\|<:\|:>\|=:=\|::\|#\)/ contained nextgroup=scalaTypeDeclaration skipwhite
+hi link scalaTypeDeclaration Type
+hi link scalaTypeExtension Keyword
+hi link scalaTypePostExtension Keyword
+
+syn match scalaTypeAnnotation /\%([_a-zA-Z0-9$\s]:\_s*\)\ze[_=(\.A-Za-z0-9$]\+/ skipwhite nextgroup=scalaTypeDeclaration contains=scalaRoundBrackets
+syn match scalaTypeAnnotation /)\_s*:\_s*\ze[_=(\.A-Za-z0-9$]\+/ skipwhite nextgroup=scalaTypeDeclaration
+hi link scalaTypeAnnotation Normal
+
+syn match scalaCaseFollowing /\<[_\.A-Za-z0-9$]\+\>/ contained
+syn match scalaCaseFollowing /`[^`]\+`/ contained
+hi link scalaCaseFollowing Special
+
+syn keyword scalaKeywordModifier abstract override final lazy implicit implicitly private protected sealed null require super
+hi link scalaKeywordModifier Function
+
+syn keyword scalaSpecial this true false ne eq
+syn keyword scalaSpecial new nextgroup=scalaInstanceDeclaration skipwhite
+syn match scalaSpecial "\%(=>\|⇒\|<-\|←\|->\|→\)"
+syn match scalaSpecial /`[^`]\+`/  " Backtick literals
+hi link scalaSpecial PreProc
+
+syn keyword scalaExternal package import
+hi link scalaExternal Include
+
+syn match scalaStringEmbeddedQuote /\\"/ contained
+syn region scalaString start=/"/ end=/"/ contains=scalaStringEmbeddedQuote,scalaEscapedChar,scalaUnicodeChar
+hi link scalaString String
+hi link scalaStringEmbeddedQuote String
+
+syn region scalaIString matchgroup=scalaInterpolationBrackets start=/\<[a-zA-Z][a-zA-Z0-9_]*"/ skip=/\\"/ end=/"/ contains=scalaInterpolation,scalaInterpolationB,scalaEscapedChar,scalaUnicodeChar
+syn region scalaTripleIString matchgroup=scalaInterpolationBrackets start=/\<[a-zA-Z][a-zA-Z0-9_]*"""/ end=/"""\%([^"]\|$\)/ contains=scalaInterpolation,scalaInterpolationB,scalaEscapedChar,scalaUnicodeChar
+hi link scalaIString String
+hi link scalaTripleIString String
+
+syn match scalaInterpolation /\$[a-zA-Z0-9_$]\+/ contained
+exe 'syn region scalaInterpolationB matchgroup=scalaInterpolationBoundary start=/\${/ end=/}/ contained contains=' . s:ContainedGroup()
+hi link scalaInterpolation Function
+hi link scalaInterpolationB Normal
+
+syn region scalaFString matchgroup=scalaInterpolationBrackets start=/f"/ skip=/\\"/ end=/"/ contains=scalaFInterpolation,scalaFInterpolationB,scalaEscapedChar,scalaUnicodeChar
+syn match scalaFInterpolation /\$[a-zA-Z0-9_$]\+\(%[-A-Za-z0-9\.]\+\)\?/ contained
+exe 'syn region scalaFInterpolationB matchgroup=scalaInterpolationBoundary start=/${/ end=/}\(%[-A-Za-z0-9\.]\+\)\?/ contained contains=' . s:ContainedGroup()
+hi link scalaFString String
+hi link scalaFInterpolation Function
+hi link scalaFInterpolationB Normal
+
+syn region scalaTripleString start=/"""/ end=/"""\%([^"]\|$\)/ contains=scalaEscapedChar,scalaUnicodeChar
+syn region scalaTripleFString matchgroup=scalaInterpolationBrackets start=/f"""/ end=/"""\%([^"]\|$\)/ contains=scalaFInterpolation,scalaFInterpolationB,scalaEscapedChar,scalaUnicodeChar
+hi link scalaTripleString String
+hi link scalaTripleFString String
+
+hi link scalaInterpolationBrackets Special
+hi link scalaInterpolationBoundary Function
+
+syn match scalaNumber /\<0[dDfFlL]\?\>/ " Just a bare 0
+syn match scalaNumber /\<[1-9]\d*[dDfFlL]\?\>/  " A multi-digit number - octal numbers with leading 0's are deprecated in Scala
+syn match scalaNumber /\<0[xX][0-9a-fA-F]\+[dDfFlL]\?\>/ " Hex number
+syn match scalaNumber /\%(\<\d\+\.\d*\|\.\d\+\)\%([eE][-+]\=\d\+\)\=[fFdD]\=/ " exponential notation 1
+syn match scalaNumber /\<\d\+[eE][-+]\=\d\+[fFdD]\=\>/ " exponential notation 2
+syn match scalaNumber /\<\d\+\%([eE][-+]\=\d\+\)\=[fFdD]\>/ " exponential notation 3
+hi link scalaNumber Number
+
+syn region scalaRoundBrackets start="(" end=")" skipwhite contained contains=scalaTypeDeclaration,scalaSquareBrackets,scalaRoundBrackets
+
+syn region scalaSquareBrackets matchgroup=scalaSquareBracketsBrackets start="\[" end="\]" skipwhite nextgroup=scalaTypeExtension contains=scalaTypeDeclaration,scalaSquareBrackets,scalaTypeOperator,scalaTypeAnnotationParameter
+syn match scalaTypeOperator /[-+=:<>]\+/ contained
+syn match scalaTypeAnnotationParameter /@\<[`_A-Za-z0-9$]\+\>/ contained
+hi link scalaSquareBracketsBrackets Type
+hi link scalaTypeOperator Keyword
+hi link scalaTypeAnnotationParameter Function
+
+syn match scalaShebang "\%^#!.*" display
+syn region scalaMultilineComment start="/\*" end="\*/" contains=scalaMultilineComment,scalaDocLinks,scalaParameterAnnotation,scalaCommentAnnotation,scalaTodo,scalaCommentCodeBlock,@Spell keepend fold
+syn match scalaCommentAnnotation "@[_A-Za-z0-9$]\+" contained
+syn match scalaParameterAnnotation "\%(@tparam\|@param\|@see\)" nextgroup=scalaParamAnnotationValue skipwhite contained
+syn match scalaParamAnnotationValue /[.`_A-Za-z0-9$]\+/ contained
+syn region scalaDocLinks start="\[\[" end="\]\]" contained
+syn region scalaCommentCodeBlock matchgroup=Keyword start="{{{" end="}}}" contained
+syn match scalaTodo "\vTODO|FIXME|XXX" contained
+hi link scalaShebang Comment
+hi link scalaMultilineComment Comment
+hi link scalaDocLinks Function
+hi link scalaParameterAnnotation Function
+hi link scalaParamAnnotationValue Keyword
+hi link scalaCommentAnnotation Function
+hi link scalaCommentCodeBlockBrackets String
+hi link scalaCommentCodeBlock String
+hi link scalaTodo Todo
+
+syn match scalaAnnotation /@\<[`_A-Za-z0-9$]\+\>/
+hi link scalaAnnotation PreProc
+
+syn match scalaTrailingComment "//.*$" contains=scalaTodo,@Spell
+hi link scalaTrailingComment Comment
+
+syn match scalaAkkaFSM /goto([^)]*)\_s\+\<using\>/ contains=scalaAkkaFSMGotoUsing
+syn match scalaAkkaFSM /stay\_s\+using/
+syn match scalaAkkaFSM /^\s*stay\s*$/
+syn match scalaAkkaFSM /when\ze([^)]*)/
+syn match scalaAkkaFSM /startWith\ze([^)]*)/
+syn match scalaAkkaFSM /initialize\ze()/
+syn match scalaAkkaFSM /onTransition/
+syn match scalaAkkaFSM /onTermination/
+syn match scalaAkkaFSM /whenUnhandled/
+syn match scalaAkkaFSMGotoUsing /\<using\>/
+syn match scalaAkkaFSMGotoUsing /\<goto\>/
+hi link scalaAkkaFSM PreProc
+hi link scalaAkkaFSMGotoUsing PreProc
+
+let b:current_syntax = 'scala'
+
+if main_syntax ==# 'scala'
+  unlet main_syntax
+endif
+
+" vim:set sw=2 sts=2 ts=8 et:

sources_non_forked/vim-scala/syntax/testfile.scala

@@ -0,0 +1,181 @@
+package testfile
+import java.something.com
+
+package object SomeObject[A <: B] extends Implicits {
+  type Booger[A] = A => Unit
+  type SomeType = A <: B :> C
+  type SomeOtherType = A ⇒ Thing
+  type Something
+  type Something <: SomethingElse
+  type ParserContext = Context { type PrefixType = Parser }
+  
+  new Something#SomethingElse
+
+  val GET, HEAD, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH = Value
+
+  // Doesn't yet work
+  val GET, HEAD: Value, POST, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATCH: Value = Value
+
+  def x: Something#SomethingElse
+
+  def hasFunctionType[A, B <: A, Z](f: A => B, g: (A, B) => Z): Unit = {
+    println("Something")
+  }
+
+  val f: (Int, String) => Unit = (i: Int, s: String) => println(s"$i -- $s")
+  val f: (Int, String) ⇒ Unit = (i: Int, s: String) ⇒ println(s"$i -- $s")
+}
+
+object Test {
+  def test(
+    param1: List[(Int, Int)],
+    param2: List[Int]):
+  List[Int] = {
+    param2 match {
+      case head :: tail => tail
+    }
+  }
+}
+
+case class ACaseClass(param1: Float = 14.23f)
+case object ACaseObject extends Something
+
+def x(): Unit = {
+  case Something(a, b) =>
+  case SomethingElse() =>
+  case SomethingElseElse =>
+}
+
+class ScalaClass(i: Int = 12, b: Trait[A, Trait[B, C]]) extends B with SomeTrait[A, B[String], D] {
+  /**
+   * I forgot comments! We spelcheck them. [[scala.Option]]
+   *
+   * {{{
+   * scala> This is a REPL line
+   * scala> and this is another one
+   * }}}
+   *
+   * <li></li>
+   *
+   * @param parameter Explanation of the parameter. Speling.
+   * @return TODO
+   */
+  val thing = "A String" // this is a trailing comment, spelchecked too [TODO]
+  val thing = "A String with a \" in it"
+  val intString = "A string with $stuff // and a comment in it"
+  val intString = s"A string /* a comment and */ with $stuff and ${stuff} in it"
+  val intString = s"""A string /* a comment and */ with $stuff and ${stuff} in it"""
+  val intFString = f"A string with $stuff and ${stuff} and ${eval this}%-2.2f and $stuff%2d in it"
+  val intFString = f"""A string with $stuff and ${stuff} and ${eval this}%-2.2f and $stuff%2d in it"""
+  val otherThings = """|This is a string
+                       |that spans multiple lines.
+                       |""".stripMargin
+  val intString = sql"select * from T where id = $id and name = ${name}"
+  val intString = sql"""
+    select * from T
+    where id = $id and name = ${s"$name Jr"} and age > ${age + 10}
+  """
+
+  val notImplemented = ???
+
+  implicit val somethingImplicit = true
+
+  // Ripped off from Scalaz
+  final def foldMap[B: Monoid](f: A => B = (a: A) => A): B = F.foldMap(self)(f)
+  final def foldRight[B](z: => B)(f: (A, => B) => B): B = F.foldRight(self, z)(f)
+  final def foldLeft[B](z: B)(f: (B, A) => B): B = F.foldLeft(self, z)(f)
+  final def foldRightM[G[_], B](z: => B)(f: (A, => B) => G[B])(implicit M: Monad[G]): G[B] = F.foldRightM(self, z)(f)
+  final def foldLeftM[G[_], B](z: B)(f: (B, A) => G[B])(implicit M: Monad[G]): G[B] = F.foldLeftM(self, z)(f)
+  final def foldr[B](z: => B)(f: A => (=> B) => B): B = F.foldr(self, z)(f)
+  final def foldl[B](z: B)(f: B => A => B): B = F.foldl(self, z)(f)
+  final def foldrM[G[_], B](z: => B)(f: A => ( => B) => G[B])(implicit M: Monad[G]): G[B] = F.foldrM(self, z)(f)
+
+  val aChar = 'a'
+  val anEscapedChar = '\\'
+  val anotherEscapedChar = '\n'
+  val aUnicodeChar = '\u00ab'
+  val aSymbol = 'SomeSymbol
+  def number = 0xAf903adeL
+  def float = 1f
+  def float = 1F
+  def float = 1.1f
+  def float = 1.1F
+  def float = 231.1232f
+  def float = 231.2321F
+  def float = .2f
+  def float = .2F
+  def double = 1d
+  def double = 1D
+  def double = 1.1d
+  def double = 1.1D
+  def double = 231.1232d
+  def double = 231.2321D
+  def double = 231.2321
+  def double = .2d
+  def double = .2
+  def double = .2D
+  def exp = 1.2342e-24
+  def exp = 1e+24
+  var flarf: Int = 12
+  def flooger(x: String): Unit = println(42)
+  private val booger = "Hithere"
+  protected[this] def something[A](y: SomeTrait[A])(implicit shoot: Function[Int, String]): Long = 12
+  private final val do = done
+
+  someVar match {
+    case Flooger(thing, that, matches) =>
+      flender ! Message(hi, there, guys)
+    case '"' => Bah
+  }
+
+  try {
+    whatever
+  } catch {
+    case e: Throwable
+  } finally {
+    at the end
+  }
+
+  while (a == b) {
+  }
+
+  for (x <- somecall) {
+    dothing
+  }
+
+  for {
+    a <- futureCall1
+    b <- futureCall2
+  } yield (a, b)
+
+  protected[package] something = null
+
+  def receive = super.receive
+
+  require(something == true)
+
+  val q"This $is a $string" = something
+
+  q"""return this $thing"""
+  tq"""return this $thing"""
+  tq"return this $thing"
+  cq"""return this $thing"""
+  cq"return this $thing"
+  pq"""return this $thing"""
+  pq"return this $thing"
+
+  val something = s"""bar="foo""""
+  val something = f"""bar="foo""""
+  val something = """bar="foo""""
+  val something = s"Interpolatin' fancy expressions ${bar map (_.toString)}"
+
+  def someFunc[A <: B, X =:= Y]
+
+  val soManyEscapes = "\\\"\u0031\n\b\r\f\t" // and a comment
+  val soManyEscapes = """\\\"\u0031\n\b\r\f\t""" // and a comment
+  val soManyEscapes = s"\\\"\u0031\n\b\r\f\t" // and a comment
+  val soManyEscapes = f"\\\"\u0031\n\b\r\f\t" // and a comment
+  val soManyEscapes = s"""\\\"\u0031\n\b\r\f\t""" // and a comment
+  val soManyEscapes = f"""\\\"\u0031\n\b\r\f\t""" // and a comment
+  val soManyEscapes = "\\\"\u0031\n\b\r\f\t" // and a comment
+}