Add hooks to run around chunk moves and batch operations. Don't err

when tramp hasn't been loaded yet.

vlf-base.el

@@ -35,6 +35,14 @@
   :group 'vlf :type 'integer)
 (put 'vlf-batch-size 'permanent-local t)
 
+(defcustom vlf-before-chunk-update nil
+  "Hook that runs before chunk update."
+  :group 'vlf :type 'hook)
+
+(defcustom vlf-after-chunk-update nil
+  "Hook that runs after chunk update."
+  :group 'vlf :type 'hook)
+
 ;;; Keep track of file position.
 (defvar vlf-start-pos 0
   "Absolute position of the visible chunk start.")
@@ -139,6 +147,7 @@ bytes added to the end."
      ((or (and (<= start vlf-start-pos) (<= edit-end end))
           (not modified)
           (y-or-n-p "Chunk modified, are you sure? "))
+      (run-hooks 'vlf-before-chunk-update)
       (let ((shift-start 0)
             (shift-end 0))
         (let ((pos (+ (position-bytes (point)) vlf-start-pos))
@@ -197,12 +206,14 @@ bytes added to the end."
           (setq vlf-start-pos start))
         (set-buffer-modified-p modified)
         (set-visited-file-modtime)
+        (run-hooks 'vlf-after-chunk-update)
         (cons shift-start shift-end))))))
 
 (defun vlf-move-to-chunk-2 (start end)
   "Unconditionally move to chunk enclosed by START END bytes.
 Return number of bytes moved back for proper decoding and number of
 bytes added to the end."
+  (run-hooks 'vlf-before-chunk-update)
   (vlf-verify-size t)
   (setq vlf-start-pos (max 0 start)
         vlf-end-pos (min end vlf-file-size))
@@ -220,6 +231,7 @@ bytes added to the end."
     (set-buffer-modified-p nil)
     (or (eq buffer-undo-list t)
         (setq buffer-undo-list nil))
+    (run-hooks 'vlf-after-chunk-update)
     shifts))
 
 (defun vlf-insert-file-contents (start end adjust-start adjust-end

vlf-ediff.el

@@ -1,4 +1,4 @@
-;;; vlf-ediff.el --- VLF ediff functionality
+;;; vlf-ediff.el --- VLF ediff functionality  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 2014 Free Software Foundation, Inc.
 
@@ -154,6 +154,7 @@ beginning of difference list."
 governed by EDIFF-BUFFER.  NEXT-FUNC is used to jump to the next
 logical chunks in case there is no difference at the current ones."
   (set-buffer buffer-A)
+  (run-hook-with-args 'vlf-before-batch-functions 'ediff)
   (setq buffer-A (current-buffer)) ;names change, so reference by buffer object
   (let ((end-A (= vlf-start-pos vlf-end-pos))
         (chunk-A (cons vlf-start-pos vlf-end-pos))
@@ -163,9 +164,11 @@ logical chunks in case there is no difference at the current ones."
         (forward-p (eq next-func 'vlf-next-chunk)))
     (font-lock-mode 0)
     (set-buffer buffer-B)
+    (run-hook-with-args 'vlf-before-batch-functions 'ediff)
     (setq buffer-B (current-buffer)
           min-file-size (min min-file-size vlf-file-size))
-    (let ((tramp-verbose (min 2 tramp-verbose))
+    (let ((tramp-verbose (if (boundp 'tramp-verbose)
+                             (min tramp-verbose 2)))
           (end-B (= vlf-start-pos vlf-end-pos))
           (chunk-B (cons vlf-start-pos vlf-end-pos))
           (font-lock-B font-lock-mode)
@@ -222,12 +225,6 @@ logical chunks in case there is no difference at the current ones."
                       (and (not end-A) (not end-B)))
                   (vlf-ediff-refine buffer-A buffer-B)))
             (setq done t))
-        (when font-lock-A
-          (set-buffer buffer-A)
-          (font-lock-mode 1))
-        (when font-lock-B
-          (set-buffer buffer-B)
-          (font-lock-mode 1))
         (unless done
           (set-buffer buffer-A)
           (set-buffer-modified-p nil)
@@ -237,7 +234,13 @@ logical chunks in case there is no difference at the current ones."
           (vlf-move-to-chunk (car chunk-B) (cdr chunk-B))
           (set-buffer ediff-buffer)
           (ediff-update-diffs)
-          (vlf-ediff-refine buffer-A buffer-B))))))
+          (vlf-ediff-refine buffer-A buffer-B))
+        (set-buffer buffer-A)
+        (if font-lock-A (font-lock-mode 1))
+        (run-hook-with-args 'vlf-after-batch-functions 'ediff)
+        (set-buffer buffer-B)
+        (if font-lock-B (font-lock-mode 1))
+        (run-hook-with-args 'vlf-after-batch-functions 'ediff)))))
 
 (defun vlf-ediff-refine (buffer-A buffer-B)
   "Try to minimize differences between BUFFER-A and BUFFER-B.

vlf-integrate.el

@@ -26,10 +26,8 @@
 
 ;;; Code:
 
-(defgroup vlf nil
+(defgroup vlf nil "View Large Files in Emacs."
-  "View Large Files in Emacs."
+  :prefix "vlf-" :group 'files)
-  :prefix "vlf-"
-  :group 'files)
 
 (defcustom vlf-application 'ask
   "Determines when `vlf' will be offered on opening files.
@@ -37,18 +35,16 @@ Possible values are: nil to never use it;
 `ask' offer `vlf' when file size is beyond `large-file-warning-threshold';
 `dont-ask' automatically use `vlf' for large files;
 `always' use `vlf' for all files."
-  :group 'vlf
+  :group 'vlf :type '(radio (const :format "%v " nil)
-  :type '(radio (const :format "%v " nil)
+                            (const :format "%v " ask)
-                (const :format "%v " ask)
+                            (const :format "%v " dont-ask)
-                (const :format "%v " dont-ask)
+                            (const :format "%v" always)))
-                (const :format "%v" always)))
 
 (defcustom vlf-forbidden-modes-list
   '(archive-mode tar-mode jka-compr git-commit-mode image-mode
                  doc-view-mode doc-view-mode-maybe ebrowse-tree-mode)
   "Major modes which VLF will not be automatically applied to."
-  :group 'vlf
+  :group 'vlf :type '(list symbol))
-  :type '(list symbol))
 
 (unless (fboundp 'file-size-human-readable)
   (defun file-size-human-readable (file-size)

vlf-occur.el

@@ -131,8 +131,10 @@ Prematurely ending indexing will still show what's found so far."
           (set (make-local-variable 'vlf-batch-size) batch-size)
           (vlf-mode 1)
           (goto-char (point-min))
+          (run-hook-with-args 'vlf-before-batch-functions 'occur)
           (vlf-with-undo-disabled
            (vlf-build-occur regexp vlf-buffer))))
+    (run-hook-with-args 'vlf-before-batch-functions 'occur)
     (let ((start-pos vlf-start-pos)
           (end-pos vlf-end-pos)
           (pos (point)))
@@ -141,11 +143,13 @@ Prematurely ending indexing will still show what's found so far."
        (goto-char (point-min))
        (unwind-protect (vlf-build-occur regexp (current-buffer))
          (vlf-move-to-chunk start-pos end-pos)
-         (goto-char pos))))))
+         (goto-char pos)))))
+  (run-hook-with-args 'vlf-before-after-functions 'occur))
 
 (defun vlf-build-occur (regexp vlf-buffer)
   "Build occur style index for REGEXP over VLF-BUFFER."
-  (let ((tramp-verbose (min 2 tramp-verbose))
+  (let ((tramp-verbose (if (boundp 'tramp-verbose)
+                           (min tramp-verbose 2)))
         (case-fold-search t)
         (line 1)
         (last-match-line 0)
@@ -244,7 +248,8 @@ in file: %s" total-matches line regexp file)
           (set-buffer-modified-p nil)
           (forward-char 2)
           (vlf-occur-mode))
-        (display-buffer occur-buffer)))))
+        (display-buffer occur-buffer))
+      (run-hook-with-args 'vlf-after-batch-functions 'occur))))
 
 (provide 'vlf-occur)
 

vlf-search.el

@@ -34,7 +34,9 @@
 BATCH-STEP is amount of overlap between successive chunks."
   (if (<= count 0)
       (error "Count must be positive"))
-  (let* ((tramp-verbose (min 2 tramp-verbose))
+  (run-hook-with-args 'vlf-before-batch-functions 'search)
+  (let* ((tramp-verbose (if (boundp 'tramp-verbose)
+                            (min tramp-verbose 2)))
          (case-fold-search t)
          (match-chunk-start vlf-start-pos)
          (match-chunk-end vlf-end-pos)
@@ -118,7 +120,8 @@ BATCH-STEP is amount of overlap between successive chunks."
                            count to-find)
          (vlf-goto-match match-chunk-start match-chunk-end
                          match-start-pos match-end-pos
-                         count to-find))))))
+                         count to-find)))))
+  (run-hook-with-args 'vlf-after-batch-functions 'search))
 
 (defun vlf-goto-match (match-chunk-start match-chunk-end
                                          match-pos-start
@@ -179,8 +182,10 @@ Search is performed chunk by chunk in `vlf-batch-size' memory."
   "Go to line N.  If N is negative, count from the end of file."
   (interactive (if (vlf-no-modifications)
                    (list (read-number "Go to line: "))))
+  (run-hook-with-args 'vlf-before-batch-functions 'goto-line)
   (vlf-verify-size)
-  (let ((tramp-verbose (min 2 tramp-verbose))
+  (let ((tramp-verbose (if (boundp 'tramp-verbose)
+                           (min tramp-verbose 2)))
         (start-pos vlf-start-pos)
         (end-pos vlf-end-pos)
         (pos (point))
@@ -244,7 +249,8 @@ Search is performed chunk by chunk in `vlf-batch-size' memory."
         (vlf-with-undo-disabled
          (vlf-move-to-chunk-2 start-pos end-pos))
         (goto-char pos)
-        (message "Unable to find line")))))
+        (message "Unable to find line"))
+      (run-hook-with-args 'vlf-after-batch-functions 'goto-line))))
 
 (provide 'vlf-search)
 

vlf-write.el

@@ -52,7 +52,9 @@ Save anyway? "))
                                 region-length)))
            (if (zerop size-change)
                (write-region nil nil buffer-file-name vlf-start-pos t)
-             (let ((tramp-verbose (min 2 tramp-verbose))
+             (run-hook-with-args 'vlf-before-batch-functions 'write)
+             (let ((tramp-verbose (if (boundp 'tramp-verbose)
+                                      (min tramp-verbose 2)))
                    (pos (point))
                    (font-lock font-lock-mode))
                (font-lock-mode 0)
@@ -66,7 +68,8 @@ Save anyway? "))
                                         (+ vlf-start-pos vlf-batch-size)
                                       vlf-end-pos))
                (vlf-update-buffer-name)
-               (goto-char pos))))))
+               (goto-char pos))
+             (run-hook-with-args 'vlf-after-batch-functions 'write)))))
   t)
 
 (defun vlf-file-shift-back (size-change)

vlf.el

@@ -39,6 +39,18 @@
 
 ;;; Code:
 
+(defcustom vlf-before-batch-functions nil
+  "Hook that runs before multiple batch operations.
+One argument is supplied that specifies current action.  Possible
+values are: `write', `ediff', `occur', `search', `goto-line'."
+  :group 'vlf :type 'hook)
+
+(defcustom vlf-after-batch-functions nil
+  "Hook that runs after multiple batch operations.
+One argument is supplied that specifies current action.  Possible
+values are: `write', `ediff', `occur', `search', `goto-line'."
+  :group 'vlf :type 'hook)
+
 (require 'vlf-base)
 
 (autoload 'vlf-write "vlf-write" "Write current chunk to file." t)