Use virtcol in blockwise visual mode

- \v  (Fix #67)
- \zs (Fix #55)

autoload/easy_align.vim

@@ -264,11 +264,8 @@ function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left,
     \ strpart(getline(a:line), a:fc - 1, a:lc - a:fc + 1) :
     \ strpart(getline(a:line), a:fc - 1)
   let idx     = 0
-  " Do not allow \zs
-  " 1: whole match
-  " 2: token
-  " 3: delimiter
-  let pattern = '^\(\(.\{-}\s*\)\(' .a:pattern. '\)\s' . (a:stick_to_left ? '*' : '\{-}') . '\)'
+  let nomagic = match(a:pattern, '\\v') > match(a:pattern, '\C\\[mMV]')
+  let pattern = '^.\{-}\s*\zs\('.a:pattern.(nomagic ? ')' : '\)')
   let tokens  = []
   let delims  = []
 
@@ -277,18 +274,22 @@ function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left,
   let token = ''
   let phantom = 0
   while 1
-    let matches = matchlist(string, pattern, idx)
+    let matchidx = match(string, pattern, idx)
     " No match
-    if empty(matches) | break | endif
+    if matchidx < 0 | break | endif
+    let matchend = matchend(string, pattern, idx)
+    let spaces = matchstr(string, '\s'.(a:stick_to_left ? '*' : '\{-}'), matchend + (matchidx == matchend))
 
-    " Match, but empty delimiter
-    if empty(matches[1])
+    " Match, but empty
+    if len(spaces) + matchend - idx == 0
       let char = strpart(string, idx, 1)
       if empty(char) | break | endif
       let [match, part, delim] = [char, char, '']
     " Match
     else
-      let [match, part, delim] = matches[1 : 3]
+      let match = strpart(string, idx, matchend - idx + len(spaces))
+      let part  = strpart(string, idx, matchidx - idx)
+      let delim = strpart(string, matchidx, matchend - matchidx)
     endif
 
     let ignorable = s:highlighted_as(a:line, idx + len(part) + a:fc, a:ignore_groups)
@@ -358,9 +359,10 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
 
   " Phase 1
   for line in range(a:fl, a:ll)
-    if f == 1 && getline(line) !~ fx
+    let snip = a:lc > 0 ? getline(line)[a:fc-1 : a:lc-1] : getline(line)
+    if f == 1 && snip !~ fx
       continue
-    elseif f == -1 && getline(line) =~ fx
+    elseif f == -1 && snip =~ fx
       continue
     endif
 
@@ -1048,12 +1050,15 @@ function! s:process(range, mode, n, ch, opts, regexp, rules, bvis)
     \ get(dict, 'align', recur == 2 ? s:alternating_modes(a:mode) : a:mode),
     \ recur)
 
+  let ve = &virtualedit
+  set ve=all
   let args = [
     \ {}, split(mode_sequence, '\zs'),
     \ {}, {}, a:range[0], a:range[1],
-    \ a:bvis             ? min([col("'<"), col("'>")]) : 1,
-    \ (!recur && a:bvis) ? max([col("'<"), col("'>")]) : 0,
+    \ a:bvis             ? min([virtcol("'<"), virtcol("'>")]) : 1,
+    \ (!recur && a:bvis) ? max([virtcol("'<"), virtcol("'>")]) : 0,
     \ nth, recur, dict ]
+  let &ve = ve
   while len(args) > 1
     let args = call('s:do_align', args)
   endwhile

test/fixed.vader

@@ -212,4 +212,38 @@ Expect:
   aa  -= bb
   aaa ?= bbb
 
+* #67 \v
+Given c:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family = AF_INET;
+  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  servaddr.sin_port = htons(SERV_PORT);
+
+Execute (#67 \v breaks surrounding regex):
+  %EasyAlign/\v(\=\s)@<=</
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
+Execute (#67 \V followed by \v shouldn't matter):
+  %EasyAlign/\v(\=\s)@<=<\V/
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
+Execute (#67 \zs is now allowed):
+  %EasyAlign/=\zs/
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
 Include: include/teardown.vader

test/interactive.vader

@@ -1535,6 +1535,63 @@ Expect:
   bbbbb=bbbbb=bbbbb
   aaa   = aaa   = aaa
 
+Given clojure (filter with blockwise-visual mode):
+  (let [a 1
+        bbb 2
+        ccccc (range
+                10 20)]
+    (prn [a bbb ccccc]))
+
+Do (filter with blockwise-visual mode):
+  f[
+  vi[
+  \<C-V>
+  \<Enter>
+  \<C-F>g/^\S\<Enter>
+  \<Space>
+
+Expect clojure:
+  (let [a     1
+        bbb   2
+        ccccc (range
+                10 20)]
+    (prn [a bbb ccccc]))
+
+Given clojure:
+  {:user {:plugins [[cider/cider-nrepl "0.9.1"]
+                    [lein-kibit "0.0.8"]
+                    [lein-licenses "0.1.1"]
+                    [lein-marginalia "0.8.0"] ; lein marg
+                    [codox "0.8.13"] ; lein doc
+                    [com.jakemccrary/lein-test-refresh "0.10.0"] ; lein test-refresh
+                    [lein-pprint "1.1.2"]
+                    [lein-exec "0.3.5"]
+                    [jonase/eastwood "0.2.1"]]
+          :dependencies [[slamhound "1.5.5"]]
+          :aliases {"slamhound" ["run" "-m" "slam.hound"]}
+          :signing {:gpg-key "FEF9C627"}}}
+
+Do (Virtual column should be used in blockwise-visual mode):
+  f[
+  vi[
+  \<C-V>
+  $20l
+  \<Enter>\<Space>
+
+Expect clojure:
+  {:user {:plugins [[cider/cider-nrepl                 "0.9.1"]
+                    [lein-kibit                        "0.0.8"]
+                    [lein-licenses                     "0.1.1"]
+                    [lein-marginalia                   "0.8.0"] ; lein marg
+                    [codox                             "0.8.13"] ; lein doc
+                    [com.jakemccrary/lein-test-refresh "0.10.0"] ; lein test-refresh
+                    [lein-pprint                       "1.1.2"]
+                    [lein-exec                         "0.3.5"]
+                    [jonase/eastwood                   "0.2.1"]]
+          :dependencies [[slamhound "1.5.5"]]
+          :aliases {"slamhound" ["run" "-m" "slam.hound"]}
+          :signing {:gpg-key "FEF9C627"}}}
+
 ###########################################################
 
 Given (hard-tab indentation (#19)):