I'm doing the react tutorial and I'm having trouble with step 3.
I put the lines in the tutorial
cd my-app
rm -f src/*
into my node.js command prompt and got "'rm' is not recognized as an internal or external command, operable program or batch file."
How can I work around this problem?
This doesn't go in your node.js prompt. It's an OS command. If you are using linux, OSX, or ubuntu-on-windows, you should type it in your terminal.
If you are using windows, you can use rmdir \S \Q src
If you are in linux or Mac OS you should do
cd my-app && rm -f src/*
This will remove all the files in src and will keep the folders its files.
If you want to remove everything from src then use:
cd my-app && rm -rf src/*
When calling CtrlP for the first time it cause quite a delay to build the cache. Is there a way to run it in the background so I can continue doing stuff in vim?
If you need to speed up indexing of CtrlP, you can use ag to grep files, exclude some folders and files from indexing, and set cache location.
To do that, put these lines in your .vimrc:
let g:ctrlp_cache_dir = $HOME . '/.cache/ctrlp'
let g:ctrlp_user_command = 'ag %s -i --nocolor --nogroup --hidden
\ --ignore .git
\ --ignore .svn
\ --ignore .hg
\ --ignore .DS_Store
\ --ignore "**/*.pyc"
\ -g ""'
You cannot do that, in fact, vim isn't multi-threaded.
You can look over for NeoVim which is multi-threaded.
Alternativly, you could use the Unite plugin and the file_rec/async command :
Note: with large projects this may cause some performance problems.
Normally it is recommended to use |unite-source-file_rec/async|
source, which requires |vimproc|.
I've installed syntastic VIM plugin by following instructions from the plugin docs via pathogen.
Install pathogen:
mkdir -p ~/.vim/autoload ~/.vim/bundle && \
curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
Install syntastic as pathogen bundle:
cd ~/.vim/bundle &&
git clone https://github.com/scrooloose/syntastic.git
At this point it's in my $HOME/.vim directory of my Linux user.
I'd like to install this plugin to be globally available for all users on the box, but I'm having trouble finding out how to go about doing it. All the instructions seem to talk about installing plugins under $HOME/.vim.
Recommended
Before you start, update your vim to the last version. If using debian, install vim.nox (python support) and run update-alternatives for vim, vi and vimdiff.
How-to
Using vim-plug I've managed to create a global plugin installation.
This is a step-by-step explanation;
create /etc/vim/autoload. Make sure others can read/execute the directory.
add plug.vim file in it. Make sure all users can read it. See below: Download
add to (preferred the begin of) your /etc/vim/vimrc.local
set runtimepath+=/etc/vim/autoload
" Initialize plugin system
call plug#begin('/etc/vim/plugged')
" Vimtemplates - templates for diverse files
Plug 'drbeco/vimtemplates', { 'do': '/etc/vim/plugged/vppinstall.sh' }
" VimColors8 - colorschemes for all
Plug 'drbeco/vimcolors8', { 'do': '/etc/vim/plugged/vppinstall.sh' }
call plug#end()
" End of initialization of plugin system
The two plugins (repositories) above, namely drbeco/vimtemplates and drbeco/vimcolors8 are optional and are there just to test the installation. You need some plugin there to run :PlugInstall and this two are small, easy and compatible. Feel free to change, but I recommend you first install all, check if it is ok, then change all vim-plug session to your taste.
Create a directory /etc/vim/plugged/. Make sure all users can read/execute it.
Add the following script to the plugged directory (make it executable):
$ cat /etc/vim/plugged/vppinstall.sh
#!/bin/bash
# notice
echo "vppinstall.sh (C) 2017 Dr. Beco: Correcting plugin's permissions"
# work in plugged directory
cd /etc/vim/plugged
# execute (open) and read directories
find . -type d ! -wholename "*/.git*" -exec chmod o+rx {} \;
# read all files
find . -type f ! -wholename "*/.git*" -exec chmod o+r {} \;
This script will run as post-installation hook to correct the permissions of the files. You can set stick-bits or redefine your UMASK instead of running this script, but unless you know the security risks I don't recommend.
Almost done.
Reload .vimrc and run :PlugInstall to install plugins.
For each new plugin you add to your vimrc.local, make sure it calls the post-installation script, or else users won't be able to use them.
--
Download
To download the plug.vim file, use:
curl -fLo /etc/vim/autoload/plug.vim https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
When using ag on the command line, like so:
$> ag . --ignore="*node_modules/*/node_modules" -l --nocolor -f -U -g ""
I am able to avoid searching through any node_modules directories more than one level deep in my node services, which is the desired behavior.
However, when I use the following in my vimrc, the node_modules directories more than one level deep are not ignored:
" Use The Silver Searcher https://github.com/ggreer/the_silver_searcher
if executable('ag')
" Use Ag over Grep
set grepprg=ag\ --nogroup\ --nocolor
" Use ag in CtrlP for listing files. Lightning fast and respects .gitignore
let g:ctrlp_user_command = 'ag %s --ignore="*node_modules/*/node_modules" -l --nocolor -f -U -g ""'
endif
How can I set up ag and ctrlp to correctly ignore those directories?
Not sure if I need to use a different syntax (like regex) or some other gotcha when transplanting to vimrc.
The reason I'm not putting this in the wildignore is that node_modules are ignored in my .gitignore, so I'm using the -U option to ignore any vcs files (thereby allowing ag to search node_modules) -- but this option also seems to bypass the wildignore.
Like you I do use both tools, but the way I ignore folders is different
For Ag I use the .agignore file, it has the same sintax as .gitignore and just like it, it can go in your home folder or project folder.
Not sure if that will solve your problem with Ctrlp, in any case it is quite fast already for me so I use the normal ignore variable like this:
let g:ctrlp_custom_ignore = {
\ 'dir': '\v[\/](doc|tmp|node_modules)',
\ 'file': '\v\.(exe|so|dll)$',
\ }
I'm trying to add Go language syntax highlighting to VIM on ubuntu with resources and direction supplied here http://go-lang.cat-v.org/text-editors/vim/.
Go comes with a go.vim file that contains syntax settings for VIM and the above page offers the following instructions
Place $GOROOT/misc/vim/syntax/go.vim in ~/.vim/syntax/ and put the following in ~/.vim/ftdetect/go.vim:
au BufRead,BufNewFile *.go set filetype=go
This is more or less the same vein of procedure for customizing vim syntax I've seen elsewhere
(Vim 7.3 on Ubuntu 12.10 doesn't have 'ftplugin' directory anywhere and https://github.com/jnwhiteh/vim-golang/blob/master/readme.txt)
So I think I'm doing the right thing when I create directories:
~/.vim
~/.vim/syntax
~/.vim/ftdetect
and follow the above instructions by adding
go.vim to ~/.vim/syntax/
and creating a file, go.vim, in ~/.vim/ftdetect/ which contains
au BufRead,BufNewFile *.go set filetype=go
Yet syntax highlighting does not seem to occur. Is there something I need to do to force VIM to look at these new settings files?
UPDATE:
Go 1.4 Release Notes
Miscellany
The standard repository's top-level misc directory used to contain Go
support for editors and IDEs: plugins, initialization
scripts and so on. Maintaining these was becoming time-consuming and
needed external help because many of the editors listed were not used
by members of the core team. It also required us to make decisions
about which plugin was best for a given editor, even for editors we do
not use.
The Go community at large is much better suited to managing this information. In Go 1.4, therefore, this support has been removed from
the repository. Instead, there is a curated, informative list of
what's available on a wiki page.
The standard Go distribution includes Go files for Vim in go/misc/vim/. This directory contains a readme.txt file which contains installation instructions.
readme.txt
Vim plugins for Go (http://golang.org)
To use all the Vim plugins, add these lines to your $HOME/.vimrc.
" Some Linux distributions set filetype in /etc/vimrc.
" Clear filetype flags before changing runtimepath to force Vim to reload them.
filetype off
filetype plugin indent off
set runtimepath+=$GOROOT/misc/vim
filetype plugin indent on
syntax on
If you want to select fewer plugins, use the instructions in the rest
of this file.
<<..SNIP..>>
On Debian, I suppose it's the same on ubuntu, you just :
sudo apt-get install vim-gocomplete gocode vim-syntax-go
vim-addon-manager install go-syntax
vim-addon-manager install gocode
you can just add these lines to your ~/.vimrc:
set rtp+=$GOROOT/misc/vim
filetype plugin indent on
syntax on
EDIT This assumes filetype plugin indent off before these lines (i.e. beginning of .vimrc file) and may cause problems if it's not. See #peterSO's answer below for the safer version.
For the best syntax highlighting try https://github.com/fatih/vim-go
It's a new project that consolidates many vim plugins and adds a lot of features. From the readme:
Improved Syntax highlighting, such as Functions, Operators, Methods..
Auto completion support via gocode
Better gofmt on save, keeps cursor position and doesn't break your undo history
Go to symbol/declaration with godef
Automatically import packages via goimports
Compile and go build your package, install it with go install
go run quickly your current file/files
Run go test and see any errors in quickfix window
Lint your code with golint
Run your code trough go vet to catch static errors.
Advanced source analysis tool with oracle
List all source files and dependencies
Checking with errcheck for unchecked errors.
Integrated and improved snippets. Supports ultisnips or neosnippet
Share your current code to play.golang.org
on 25/Jan/2015
Please see https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins as now all editor & shell support in Go repo is removed (https://codereview.appspot.com/105470043)
I did not find instructions on turning on vim syntax highlighting for CentOS 7. Have tested the ensuing instructions to work on CentOS 7.3.1611. First, create the following directory in your home directory:
$ mkdir ~/.vim/ftdetect/
Then, create a file named, go.vim inside the above directory with the contents:
au BufRead,BufNewFile *.go set filetype=go
Download the syntax definition file for Go: vim.go. Transfer it to the right system-wide directory so that multiple users can share:
$ sudo mv -i go.vim /usr/share/vim/vim74/syntax/
For whatever reason outside of my own decision making, we got Golang installed on our dev VMs by Debian packages. This particular distribution of vim doesn't come with any of the goodies for vim as far as I was able to tell from a search around for it. Anyways, I decided to go the vundle route in order to rapidly deploy the goodies to all these dev VMs. You could probably work this method into puppet or something if you'd like, we didn't do that though. Anyways, here's what I did:
Step 1: Install vundle:
https://github.com/gmarik/vundle
Step 2: put this line in your .vimrc (It's from here, of course: https://github.com/jnwhiteh/vim-golang ), and then run vim from the command line like vim +BundleInstall +qall or from within vim with :BundleInstall
Bundle 'jnwhiteh/vim-golang'
Step 3: Save this little bash script I whipped up as govim.sh or whatever, chmod +x govim.sh, and run it like ./govim.sh
Script as follows:
#!/bin/bash
mkdir $HOME/.vim/ftdetect
mkdir $HOME/.vim/syntax
mkdir $HOME/.vim/autoload
mkdir $HOME/.vim/autoload/go
mkdir $HOME/.vim/ftplugin
mkdir $HOME/.vim/ftplugin/go
mkdir $HOME/.vim/indent
mkdir $HOME/.vim/compiler
mkdir $HOME/.vim/plugin
mkdir $HOME/.vim/plugin/godoc
ln -s $HOME/.vim/bundle/vim-golang/ftdetect/gofiletype.vim $HOME/.vim/ftdetect
ln -s $HOME/.vim/bundle/vim-golang/syntax/go.vim $HOME/.vim/syntax/
ln -s $HOME/.vim/bundle/vim-golang/autoload/go/complete.vim $HOME/.vim/autoload/go/
ln -s $HOME/.vim/bundle/vim-golang/ftplugin/go.vim $HOME/.vim/ftplugin/
ln -s $HOME/.vim/bundle/vim-golang/ftplugin/go/*.vim $HOME/.vim/ftplugin/go/
ln -s $HOME/.vim/bundle/vim-golang/indent/go.vim $HOME/.vim/indent/
ln -s $HOME/.vim/bundle/vim-golang/compiler/go.vim $HOME/.vim/compiler/
ln -s $HOME/.vim/bundle/vim-golang/plugin/godoc/godoc.vim $HOME/.vim/plugin/godoc/
ln -s $HOME/.vim/bundle/vim-golang/syntax/godoc.vim $HOME/.vim/syntax/
Kaching! You now have all the goodies installed, and someone correct me if I'm wrong on this but perhaps more than what comes with the official Golang distribution. I don't know about this either having not tried it yet, but I think that the runtimepath/rtp gets clobbered if you use Vundle with the other answers here anyways.
It should be easy as 1, 2, 3 :
Download the file vim.go and place in in ~/.vim/syntax under the name go.vim (create the directory syntax if you don't already have it).
If you don't already have the file ~/.vim/ftdetect/go.vim, create it (and the folder if necessary).
In .vim/ftdetect/go.vim, add the following line : au BufRead,BufNewFile *.go set filetype=go
This page says that:
Place $GOROOT/misc/vim/syntax/go.vim in ~/.vim/syntax/
and put the following in ~/.vim/ftdetect/go.vim:
au BufRead,BufNewFile *.go set filetype=go
It worked for me, only i did not find the /misc/vim/go.vim directory at first. So i copied the files from another computer that had installed go on /usr/local/go/...
This is what worked for me in MAC
Install vim-go - https://github.com/fatih/vim-go
Set the .vimrc to the following
let g:tagbar_type_go = {
\ 'ctagstype' : 'go',
\ 'kinds' : [
\ 'p:package',
\ 'i:imports:1',
\ 'c:constants',
\ 'v:variables',
\ 't:types',
\ 'n:interfaces',
\ 'w:fields',
\ 'e:embedded',
\ 'm:methods',
\ 'r:constructor',
\ 'f:functions'
\ ],
\ 'sro' : '.',
\ 'kind2scope' : {
\ 't' : 'ctype',
\ 'n' : 'ntype'
\ },
\ 'scope2kind' : {
\ 'ctype' : 't',
\ 'ntype' : 'n'
\ },
\ 'ctagsbin' : 'gotags',
\ 'ctagsargs' : '-sort -silent'
\ }
let g:go_highlight_structs = 1
let g:go_highlight_methods = 1
let g:go_highlight_functions = 1
let g:go_highlight_operators = 1
let g:go_highlight_build_constraints = 1
syntax on
Install gotags - e.g. brew install gotags
Generate ctags - e.g. gorags -R . > ./tags
Open vim from the new shell
Turns out the directions above were slightly ambiguous.
~/.vim/syntax/go.vim should have the same contents as ~/.vim/ftdetect/go.vim
only ~/.vim/ftdetect/go.vim must be appended with au BufRead,BufNewFile *.go set filetype=go.
If taken literally, the directions tell you to create a file ~/.vim/ftdetect/go.vim containing only
au BufRead,BufNewFile *.go set filetype=go
I suppose that's where contextual knowledge should kick in. Only I'd never done this before and had no such context. Thanks all!