| Age | Commit message (Collapse) | Author |
|---|
|
If there's a diff in the index, that will get included in the output of
this command, meaning that just after the SHA, there will be a
multi-line diff string that completely messes up the constructed URL.
Use the `--no-patch` flag to suppress diff output.
|
|
Improve performance by eliminating the functions from the `plugin` file.
Also introduces a new `github_url#GitHubURL()` function that serves as
an entry point into the plugin.
Add a `g:loaded_github_url` check to prevent plugin re-sourcing and be a
good Vim citizen.
|
|
I used this for testing purposes but it's no longer relevant.
|
|
Add doc comments to these functions.
|
|
If the command was executed as:
:6GitHubFileURL
we previously appended `#L6-L6` to the URL. This change appends only
`#L6` in that case.
|
|
Using a `count` of 0 allows us to determine in `s:FileURL` whether a
range was given on the command line.
This count needs to be passed into the function explicitly with
`<count>`.
|
|
A rough working implementation of a plugin that generates a GitHub URL
for the current file.
It gets the base URL from the current Git repo's `origin` remote and
uses the current commit SHA. Lines can also be highlighted by passing a
range to the command.
This makes it easier to share a bit of code that I see in the editor
with other people on my team in chat or the issue tracker.
|
|
When the `<Enter>` key is pressed in the GitBlamer window, run
`!git show` on the commit from the current cursor line of the blame.
This allows a changed line to be inspected in the context of its
original changeset. It also saves me time from my previous workflow:
cpe^Zgit show <Apple-P><Enter>
|
|
Previously, when the GitBlamer window was closed, the window it was
opened from would not be re-focused. Because of this, you couldn't just
pick up where you left off, you had to run a window command first.
This change re-focuses the original window automatically, bringing you
right where you were before opening GitBlamer.
Unfortunately, this seemingly simple want is not easy to do in VimL.
There's a `WinLeave` autocmd, but that event gets executed _before_
leaving a window. Similarly, the `BufWinLeave` autocmd we already had
gets executed before the buffer is removed from the window. Because
these events happen before the window is left, running the `wincmd w`
command doesn't work. We need a way to run the command after the window
is closed, allowing us to work with the new window layout and window
numbers.
In order to run `wincmd w` at the proper time, we add a new autocmd upon
closing the GitBlamer window that gets executed when any window is
entered. That autocmd refocuses the correct window and removes itself,
having served its purpose.
I used a tab variable to store the window number because it was a way to
allow multiple GitBlamer instances in different tabs. Otherwise, the
autocmd would be attached to a window that isn't correct in other tabs.
Also, augroups can't have dynamic names, so we can't create them
programmatically, preventing us from having multiple autocmds with
different window numbers for different tabs. The disadvantage of using a
tab variable is that window focus restoration doesn't work when multiple
GitBlamers are opened in a single tab.
|
|
If `nowrap` is set, the plugin causes an error because it tries to
concatenate the `restore` variable which hasn't been defined. Define the
variable outside the `if &l:wrap` condition to ensure it's available for
concatenation.
|
|
In order to get the cursor lines to correctly match up horizontally in
all cases, set 'nowrap' on the buffer.
To set 'wrap' back, follow fugitive.vim's example:
https://github.com/tpope/vim-fugitive/blob/f3ccb0c12ee4985b8808f83059830a24cc92821c/plugin/fugitive.vim#L2038-L2040
|
|
Makes it just a bit easier to close the GitBlamer window. Since we
shouldn't need macros in this panel it should be fine.
|
|
Adding `syncbind` appears to fix the bug where in certain cases the
GitBlamer cursor line and the buffer cursor line weren't horizontally
aligned.
|
|
Use the `cursor()` function to set the position of the cursor. This call
is simpler than `setpos()`, and more descriptive than `execute
l:top_line` (that was inspired by fugitive.vim,
https://github.com/tpope/vim-fugitive/blob/f3ccb0c12ee4985b8808f83059830a24cc92821c/plugin/fugitive.vim#L2048-L2064)
|
|
Take the mechanism that Fugitive.vim uses:
https://github.com/tpope/vim-fugitive/blob/f3ccb0c12ee4985b8808f83059830a24cc92821c/plugin/fugitive.vim#L2048-L2064
This positions the cursor lines on the same horizontal line so that
blame information can be read on the same line as the code it
corresponds to.
Not sure, but it doesn't seem to work exactly right on one of my
machines, but did appear to work correctly on another. Could just be the
fault of 'wrap' though.
|
|
I don't really like these any more.
|
|
In some instances with more than one window open, closing the GitBlamer
window would cause other windows in the tab to have `cursorbind` (and
presumably `scrollbind`) set.
Fix the bug by setting `scrollbind` and `cursorbind` on the buffer
(these are window-local variables, we'll have to find out if it's weird
to set them on a buffer), and store the "restore" command in a
buffer-local variable (local to the GitBlamer window).
|
|
Facilitates opening Rails locale files in alternate languages.
|
|
Adds two new commands that allow you to move to the beginning and end of
undo history.
|
|
Fixes a bug where pressing `gG` without first having used `[count]G` to
store a location caused an error.
|
|
Doesn't clobber saved location when using `G` without a count.
|
|
Show the completion menu even when there's only one result so we can
still read the commit message subject. This allows for easy validation
that we've autocompleted the right commit SHA.
|
|
If the commands result in errors, they should fail silently, because we
may have exected them on things that don't match, like a line that has
no '.'s or a single-line buffer.
|
|
Don't force the function to load on startup.
|
|
Give the plugin a clearer name.
|
|
A new plugin to split method chains onto multiple lines.
For example:
scope.line.result(distinct: true).paginate
becomes:
scope
.line
.result(distinct: true)
.paginate
|
|
Provides completion of Git SHAs in commit messages. Super handy for
referencing other commits without having to copy-paste and use the
mouse. Was getting tired of that routine.
|
|
Was getting annoyed at having to manually split function arguments from
a single line to multiple lines. Planned on writing a little custom
plugin to do this, but this one seems more well thought out and
featureful than what I was thinking of. It also seems lighter and not as
presumptive as another alternative I found:
https://github.com/AndrewRadev/splitjoin.vim
|
|
Finally getting annoyed enough about not being able to '.'-repeat
surround.vim commands. It's really nice to have repeating just work now.
|
|
A plugin that will insert a given month from the `cal` program and
format it such that I can insert `*`s next to days to flag them.
I've been doing this manually for years and it finally seemed time to
automate the process.
|
|
Make it more efficient to run RSpec tests right in Vim. It's been nearly
4 weeks since I started writing Rails code full time and I'd like to see
if I can have a nicer system for running only the tests I'm interested
in or working on at the moment.
|
|
It's been a few years and it turns out there's some cool new stuff in
Surround, like support for arbitrary characters and other goodies.
|
|
This plugin has been sitting uncommitted in my .vim for many months now.
I originally hadn't added it to the repo because it wasn't published.
Now that it is, I can use the plugin's public Git link.
Helps me keep track of my to-dos.
|
|
Based on my current Vim settings, splits open to the right (I have
`splitright` turned on).
This causes the blame window to open to the right of the file in
question, which is weird, since normally that metadata appears to the
left of the file.
Open the Blamer split on the left by default to make the formatting more
consistent with the normal `git blame` output.
|
|
A new plugin that cycles through a list of languages to use when spell
checking. Using a couple of mappings, we can quickly change the
`spelllang` to the language we want to write or read in.
Languages are currently set to English and French, since those are the
two that I use. The mappings are bound to `[l` and `]l` (in
unimpaired.vim style) since those didn't seem to be used by anything.
|
|
This plugin has been in my `bundle/` directory for nearly a year
uncommitted. I think it's about time we formally inducted it, and made
my game an official part of my vimrc.
|
|
I've had the plugin disabled but uncommitted for many months now. I
think it's finally time to make the change official.
Slimv is an excellent plugin, and makes it possible to have a good Common
Lisp development environment in Vim. I'll still be using it for that
reason.
The trouble is that Slimv isn't a good plugin citizen: It overrides user
defaults. I noticed that at some point many months ago, code I was
writing was getting auto-indented. The "smart" kind of autoindent, not
`set autoindent`. I _hate_ "smart" auto-indenting. Figured out that
Slimv was the cause and immediately disabled the plugin.
We may want to create a Bash alias that we can use exclusively for CL
development that loads Slimv into the runtimepath instead of having it
auto-loaded by Pathogen.
|
|
Fixes bug where `G` didn't push to the jumplist.
|
|
This commit introduces compatibility with pick's latest 1.4.0 release.
|
|
The Rust language's Vim plugin.
|
|
Working Emacs with Evil-mode and SLIME felt pretty slow compared to my
normal Vim speed. Trying Slimv to see if I can make it work for Common
Lisp development in Vim.
|
|
Fixes `G` mapping and errors when executing `:AuditoryOn` and
`:AuditoryOff` twice in a row.
|
|
A custom plugin that invokes a system copy to OS X's pasteboard using
`pbcopy` via a Vim command. This allows us to specify a range of lines
to copy in command mode, similar to the way that Chris Toomey's System
Copy plugin provides an easy way to invoke a system copy using motions.
With this plugin we can write:
:5,21Copy
to copy those lines.
:12,'aCopy
will also work.
If your Vim is compiled with `+clipboard` support, you would instead
write:
:15,24y *
Since I use a Vim that doesn't have clipboard support, I decided to use
a plugin to get the same functionality rather than compile a new Vim.
|
|
To facilitate Vim plugin development.
|
|
To take advangage of the newly `<silent>` `G` command.
|
|
This will finally give me a way to repeat `G` commands. Should be useful
since I often find myself entering a `G` command only to realise that I
was in the wrong window and have to then type the whole thing again.
With this plugin all I have to do is type a quick mapping to make the
repeat happen.
|
|
Add the `-w` flag to our `git blame` call in order to ignore whitespace
changes so we can see who originally introduced a line's change even if
there were subsequent whitespace changes made to the line.
|
|
Testing this plugin out. The hope is that it will allow me to quickly
open the relevant bits of code from a stack trace. This also works
without a `makeprg` so I could use if for Django stack traces for
example. Still trying to get it to work.
|
|
|
|
Big thanks to Chris Toomey for creating this plugin. Something I was
trying to achieve using my v_<leader>c mapping but which never felt
right, especially since that only ever allowed me linewise copies and no
characterwise ones.
Found out about this one at the Boston Vim meetup back on May 20 (or
maybe rediscovered, as it sounded familiar but I obviously never pursued
it).
This is something I've been wanting for a long while, as my own mapping
for it worked fine but wasn't the most ideal.
|
