[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/lentic 582d4d72b3 125/333: Search and Replace to lentic
|
From: |
ELPA Syncer |
|
Subject: |
[elpa] externals/lentic 582d4d72b3 125/333: Search and Replace to lentic. |
|
Date: |
Tue, 27 Feb 2024 13:00:16 -0500 (EST) |
branch: externals/lentic
commit 582d4d72b332c98c1430d01abcc4ffb5a638f229
Author: Phillip Lord <phillip.lord@newcastle.ac.uk>
Commit: Phillip Lord <phillip.lord@newcastle.ac.uk>
Search and Replace to lentic.
As we are renaming the package we need to move all the references to
linked-buffer.
---
.dir-locals.el | 2 +-
.ert-runner | 2 +-
Cask | 2 +-
lentic-asciidoc.el | 84 ++++-----
lentic-block.el | 164 ++++++++---------
lentic-delayed.el | 90 ++++-----
lentic-dev.el | 34 ++--
lentic-latex-code.el | 46 ++---
lentic-org.el | 160 ++++++++--------
lentic.el | 511 ++++++++++++++++++++++++++-------------------------
test/lentic-test.el | 174 +++++++++---------
11 files changed, 635 insertions(+), 634 deletions(-)
diff --git a/.dir-locals.el b/.dir-locals.el
index 30cc062014..e054b93a56 100644
--- a/.dir-locals.el
+++ b/.dir-locals.el
@@ -2,4 +2,4 @@
.
((eval .
(progn (require 'm-buffer)
- (setq linked-buffer-init 'linked-buffer-orgel-org-init))))))
+ (setq lentic-init 'lentic-orgel-org-init))))))
diff --git a/.ert-runner b/.ert-runner
index 14ced4d6e3..c4486c08ea 100644
--- a/.ert-runner
+++ b/.ert-runner
@@ -1 +1 @@
---load linked-buffer.el linked-buffer-block.el linked-buffer-latex-code
linked-buffer-asciidoc linked-buffer-org test/linked-buffer-test.el
\ No newline at end of file
+--load lentic.el lentic-block.el lentic-latex-code lentic-asciidoc lentic-org
test/lentic-test.el
\ No newline at end of file
diff --git a/Cask b/Cask
index e942cb6a8c..5f576e0668 100644
--- a/Cask
+++ b/Cask
@@ -3,7 +3,7 @@
(source melpa-stable)
(source marmalade)
-(package-file "linked-buffer.el")
+(package-file "lentic.el")
(development
(depends-on "f")
diff --git a/lentic-asciidoc.el b/lentic-asciidoc.el
index 1b698903b3..5b39a72b48 100644
--- a/lentic-asciidoc.el
+++ b/lentic-asciidoc.el
@@ -1,4 +1,4 @@
-;;; linked-buffer-asciidoc.el --- asciidoc support for linked-buffer -*-
lexical-binding: t -*-
+;;; lentic-asciidoc.el --- asciidoc support for lentic -*- lexical-binding: t
-*-
;; This file is not part of Emacs
@@ -27,11 +27,11 @@
;; Linked buffers with asciidoc [source] blocks.
;;; Code:
-(require 'linked-buffer-block)
+(require 'lentic-block)
(require 'm-buffer)
-(defun linked-buffer-asciidoc-commented-new ()
- (linked-buffer-commented-asciidoc-configuration
+(defun lentic-asciidoc-commented-new ()
+ (lentic-commented-asciidoc-configuration
"lb-commented-clojure asciidoc"
:this-buffer (current-buffer)
:linked-file
@@ -40,15 +40,15 @@
(buffer-file-name)) ".adoc")
:comment ";; "))
-(defun linked-buffer-clojure-asciidoc-init ()
- (setq linked-buffer-config
- (linked-buffer-asciidoc-commented-new)))
+(defun lentic-clojure-asciidoc-init ()
+ (setq lentic-config
+ (lentic-asciidoc-commented-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-clojure-asciidoc-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-clojure-asciidoc-init)
-(defun linked-buffer-asciidoc-uncommented-new ()
- (linked-buffer-uncommented-asciidoc-configuration
+(defun lentic-asciidoc-uncommented-new ()
+ (lentic-uncommented-asciidoc-configuration
"lb-uncommented-clojure-asciidoc"
:this-buffer (current-buffer)
:linked-file
@@ -57,29 +57,29 @@
(buffer-file-name)) ".clj")
:comment ";; "))
-(defun linked-buffer-asciidoc-clojure-init ()
- (setq linked-buffer-config
- (linked-buffer-asciidoc-uncommented-new)))
+(defun lentic-asciidoc-clojure-init ()
+ (setq lentic-config
+ (lentic-asciidoc-uncommented-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-asciidoc-clojure-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-asciidoc-clojure-init)
-(defclass linked-buffer-commented-asciidoc-configuration
- (linked-buffer-commented-block-configuration)
+(defclass lentic-commented-asciidoc-configuration
+ (lentic-commented-block-configuration)
((srctags :initarg :srctags
:documentation "Language tags in source block"
:initform '("clojure" "lisp")))
"Linked buffer config for asciidoc and other code.")
-(defclass linked-buffer-uncommented-asciidoc-configuration
- (linked-buffer-uncommented-block-configuration)
+(defclass lentic-uncommented-asciidoc-configuration
+ (lentic-uncommented-block-configuration)
((srctags :initarg :srctags
:documentation "Language tags in source block"
:initform '("clojure" "lisp")))
"Linked buffer config for asciidoc and other code")
-(defun linked-buffer-splitter (l)
+(defun lentic-splitter (l)
"Returns a function which for use as a partition predicate.
The returned function returns the first element of L until it is
passed a value higher than the first element, then it returns the
@@ -91,7 +91,7 @@ second element and so on."
(setq l (-drop 1 l)))
(car l)))
-(defun linked-buffer-partition-after-source (l-source l-dots)
+(defun lentic-partition-after-source (l-source l-dots)
"Given a set of markers l-source, partition the markers in
l-dots.
@@ -100,14 +100,14 @@ next matches to \"....\" immediately after a [source]
marker.
This should remove other \"....\" matches.
"
(-partition-by
- (linked-buffer-splitter l-source)
+ (lentic-splitter l-source)
(-drop-while
(lambda (x)
(and l-source
(< x (car l-source))))
l-dots)))
-(defun linked-buffer-block-match-asciidoc
+(defun lentic-block-match-asciidoc
(conf buffer)
(let* ((source
(m-buffer-match-begin
@@ -120,39 +120,39 @@ This should remove other \"....\" matches.
(m-buffer-match buffer
"^;* *----"))
(source-start
- (linked-buffer-partition-after-source
+ (lentic-partition-after-source
source
(m-buffer-match-begin
dots)))
(source-end
- (linked-buffer-partition-after-source
+ (lentic-partition-after-source
source (m-buffer-match-end dots))))
(when source
(list
(-map 'cadr source-start)
(-map 'car source-end)))))
-(defmethod linked-buffer-block-match
- ((conf linked-buffer-commented-asciidoc-configuration) buffer)
- (linked-buffer-block-match-asciidoc conf buffer))
+(defmethod lentic-block-match
+ ((conf lentic-commented-asciidoc-configuration) buffer)
+ (lentic-block-match-asciidoc conf buffer))
-(defmethod linked-buffer-block-match
- ((conf linked-buffer-uncommented-asciidoc-configuration) buffer)
- (linked-buffer-block-match-asciidoc conf buffer))
+(defmethod lentic-block-match
+ ((conf lentic-uncommented-asciidoc-configuration) buffer)
+ (lentic-block-match-asciidoc conf buffer))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-commented-asciidoc-configuration))
+(defmethod lentic-invert
+ ((conf lentic-commented-asciidoc-configuration))
(let ((rtn
- (linked-buffer-asciidoc-uncommented-new)))
- (oset rtn :that-buffer (linked-buffer-this conf))
+ (lentic-asciidoc-uncommented-new)))
+ (oset rtn :that-buffer (lentic-this conf))
rtn))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-uncommented-asciidoc-configuration))
+(defmethod lentic-invert
+ ((conf lentic-uncommented-asciidoc-configuration))
(let ((rtn
- (linked-buffer-asciidoc-commented-new)))
- (oset rtn :that-buffer (linked-buffer-this conf))
+ (lentic-asciidoc-commented-new)))
+ (oset rtn :that-buffer (lentic-this conf))
rtn))
-(provide 'linked-buffer-asciidoc)
-;;; linked-buffer-asciidoc.el ends here
+(provide 'lentic-asciidoc)
+;;; lentic-asciidoc.el ends here
diff --git a/lentic-block.el b/lentic-block.el
index d766d113ad..2db893dab7 100644
--- a/lentic-block.el
+++ b/lentic-block.el
@@ -1,4 +1,4 @@
-;;; linked-buffer-block.el --- Comment blocks in one buffer -*-
lexical-binding: t -*-
+;;; lentic-block.el --- Comment blocks in one buffer -*- lexical-binding: t -*-
;; This file is not part of Emacs
@@ -24,14 +24,14 @@
;;; Commentary:
;;
-;; Provides configuration for linked-buffers where one buffer has beginning of
+;; Provides configuration for lentics where one buffer has beginning of
;; line comment characters that the other one lacks. Commented regions may be
;; in blocks with block-delimiters between then.
(require 'm-buffer)
-(require 'linked-buffer)
+(require 'lentic)
;;; Code:
-(defclass linked-buffer-block-configuration
(linked-buffer-default-configuration)
+(defclass lentic-block-configuration (lentic-default-configuration)
((comment :initarg :comment
:documentation "The comment character")
(comment-start :initarg :comment-start
@@ -44,46 +44,46 @@
:documentation
"Should match be case sensitive"
:initform :default))
- :documentation "Base configuration for blocked linked-buffers.
-A blocked linked-buffer is one where blocks of the buffer have a
+ :documentation "Base configuration for blocked lentics.
+A blocked lentic is one where blocks of the buffer have a
start of line block comment in one buffer but not the other."
:abstract t)
-(defmethod linked-buffer-blk-comment-start-regexp
- ((conf linked-buffer-block-configuration))
+(defmethod lentic-blk-comment-start-regexp
+ ((conf lentic-block-configuration))
;; todo -- what does this regexp do?
(format "^\\(%s\\)*%s"
(oref conf :comment)
(regexp-quote
(oref conf :comment-start))))
-(defmethod linked-buffer-blk-comment-stop-regexp
- ((conf linked-buffer-block-configuration))
+(defmethod lentic-blk-comment-stop-regexp
+ ((conf lentic-block-configuration))
(format "^\\(%s\\)*%s"
(oref conf :comment)
(regexp-quote
(oref conf :comment-stop))))
-(defmethod linked-buffer-blk-line-start-comment
- ((conf linked-buffer-block-configuration))
+(defmethod lentic-blk-line-start-comment
+ ((conf lentic-block-configuration))
(concat "^"
(oref conf :comment)))
-(defun linked-buffer-blk-uncomment-region (conf begin end buffer)
+(defun lentic-blk-uncomment-region (conf begin end buffer)
"Given CONF, remove start-of-line characters in region.
Region is between BEGIN and END in BUFFER. CONF is a
-function `linked-buffer-configuration' object."
- ;;(linked-buffer-log "uncomment-region (%s,%s)" begin end)
+function `lentic-configuration' object."
+ ;;(lentic-log "uncomment-region (%s,%s)" begin end)
(m-buffer-with-markers
((comments
(m-buffer-match
buffer
- (linked-buffer-blk-line-start-comment conf)
+ (lentic-blk-line-start-comment conf)
:begin begin :end end)))
(m-buffer-replace-match comments "")))
-(defun linked-buffer-blk-uncomment-buffer (conf begin end buffer)
- "Given CONF, a `linked-buffer-configuration' object, remove all
+(defun lentic-blk-uncomment-buffer (conf begin end buffer)
+ "Given CONF, a `lentic-configuration' object, remove all
start of line comment-characters in appropriate blocks. Changes
should only have occurred between BEGIN and END in BUFFER."
(-map
@@ -95,15 +95,15 @@ should only have occurred between BEGIN and END in BUFFER."
(when
(and (>= end block-begin)
(>= block-end begin))
- (linked-buffer-blk-uncomment-region
+ (lentic-blk-uncomment-region
conf block-begin block-end buffer))))
- (linked-buffer-blk-marker-boundaries
+ (lentic-blk-marker-boundaries
conf buffer)))
-(defun linked-buffer-blk-comment-region (conf begin end buffer)
- "Given CONF, a `linked-buffer-configuration' object, add
+(defun lentic-blk-comment-region (conf begin end buffer)
+ "Given CONF, a `lentic-configuration' object, add
start of line comment characters beween BEGIN and END in BUFFER."
- (linked-buffer-log "comment-region (%s,%s,%s)" begin end buffer)
+ (lentic-log "comment-region (%s,%s,%s)" begin end buffer)
(m-buffer-with-markers
((line-match
(m-buffer-match
@@ -115,15 +115,15 @@ start of line comment characters beween BEGIN and END in
BUFFER."
buffer
;; start to end of line which is what this regexp above matches
(concat
- (linked-buffer-blk-line-start-comment conf)
+ (lentic-blk-line-start-comment conf)
".*")
:begin begin :end end)))
(m-buffer-replace-match
(m-buffer-match-exact-subtract line-match comment-match)
(oref conf :comment) nil nil 1)))
-(defun linked-buffer-blk-comment-buffer (conf begin end buffer)
- "Given CONF, a `linked-buffer-configuration' object, add
+(defun lentic-blk-comment-buffer (conf begin end buffer)
+ "Given CONF, a `lentic-configuration' object, add
start of line comment-characters. Changes should only have occurred
between BEGIN and END in BUFFER."
;; we need these as markers because the begin and end position need to
@@ -141,9 +141,9 @@ between BEGIN and END in BUFFER."
(when
(and (>= end block-begin)
(>= block-end begin))
- (linked-buffer-blk-comment-region
+ (lentic-blk-comment-region
conf (car pairs) (cdr pairs) buffer))))
- (linked-buffer-blk-marker-boundaries conf buffer))))
+ (lentic-blk-marker-boundaries conf buffer))))
(put 'unmatched-delimiter-error
'error-conditions
@@ -152,13 +152,13 @@ between BEGIN and END in BUFFER."
(put 'unmatched-delimiter-error
'error-message "Unmatched Delimiter in Buffer")
-(defun linked-buffer-blk-marker-boundaries (conf buffer)
- "Given CONF, a `linked-buffer-configuration' object, find
+(defun lentic-blk-marker-boundaries (conf buffer)
+ "Given CONF, a `lentic-configuration' object, find
demarcation markers. Returns a list of start end cons pairs.
`point-min' is considered to be an implicit start and `point-max'
an implicit stop."
(let* ((match-block
- (linked-buffer-block-match
+ (lentic-block-match
conf buffer))
(match-start
(car match-block))
@@ -167,7 +167,7 @@ an implicit stop."
(unless
(= (length match-start)
(length match-end))
- (linked-buffer-log "delimiters do not match")
+ (lentic-log "delimiters do not match")
(signal 'unmatched-delimiter-error
(list buffer)))
(with-current-buffer buffer
@@ -183,19 +183,19 @@ an implicit stop."
match-end
(list (set-marker (make-marker) (point-max) buffer)))))))
-(defmethod linked-buffer-block-match ((conf linked-buffer-block-configuration)
+(defmethod lentic-block-match ((conf lentic-block-configuration)
buffer)
(list
(m-buffer-match-begin
buffer
- (linked-buffer-block-comment-start-regexp conf)
+ (lentic-block-comment-start-regexp conf)
:case-fold-search (oref conf :case-fold-search))
(m-buffer-match-end
buffer
- (linked-buffer-block-comment-stop-regexp conf)
+ (lentic-block-comment-stop-regexp conf)
:case-fold-search (oref conf :case-fold-search))))
-(defmethod linked-buffer-convert ((conf linked-buffer-block-configuration)
+(defmethod lentic-convert ((conf lentic-block-configuration)
location)
"Converts a LOCATION in buffer FROM into one from TO.
This uses a simple algorithm; we pick the same line and then
@@ -207,7 +207,7 @@ between the two buffers; we don't care which one has
comments."
;; data as a list rather than having two with-current-buffers.
(let ((line-plus
(with-current-buffer
- (linked-buffer-this conf)
+ (lentic-this conf)
(save-excursion
;; move to location or line-end-position may be wrong
(goto-char location)
@@ -218,7 +218,7 @@ between the two buffers; we don't care which one has
comments."
(- (line-end-position)
location))))))
(with-current-buffer
- (linked-buffer-that conf)
+ (lentic-that conf)
(save-excursion
(goto-char (point-min))
;; move forward to the line in question
@@ -230,28 +230,28 @@ between the two buffers; we don't care which one has
comments."
(cadr line-plus)))))))
-(defclass linked-buffer-commented-block-configuration
- (linked-buffer-block-configuration)
+(defclass lentic-commented-block-configuration
+ (lentic-block-configuration)
()
- "Configuration for blocked linked-buffer with comments.")
+ "Configuration for blocked lentic with comments.")
-(defclass linked-buffer-uncommented-block-configuration
- (linked-buffer-block-configuration)
+(defclass lentic-uncommented-block-configuration
+ (lentic-block-configuration)
()
- "Configuration for blocked linked-buffer without comments.")
+ "Configuration for blocked lentic without comments.")
-(defun linked-buffer-bolp (buffer position)
+(defun lentic-bolp (buffer position)
(with-current-buffer
buffer
(save-excursion
(goto-char position)
(bolp))))
-(defmethod linked-buffer-clone
- ((conf linked-buffer-commented-block-configuration)
+(defmethod lentic-clone
+ ((conf lentic-commented-block-configuration)
&optional start stop length-before start-converted stop-converted)
- "Update the contents in the linked-buffer without comments"
- ;;(linked-buffer-log "blk-clone-uncomment (from):(%s)" conf)
+ "Update the contents in the lentic without comments"
+ ;;(lentic-log "blk-clone-uncomment (from):(%s)" conf)
(let*
;; we need to detect whether start or stop are in the comment region at
;; the beginning of the file. We check this by looking at :that-buffer
@@ -264,7 +264,7 @@ between the two buffers; we don't care which one has
comments."
((start-in-comment
(when
(and start
- (linked-buffer-bolp
+ (lentic-bolp
(oref conf :that-buffer)
start-converted))
(m-buffer-with-current-location
@@ -283,7 +283,7 @@ between the two buffers; we don't care which one has
comments."
(stop-in-comment
(when
(and start
- (linked-buffer-bolp
+ (lentic-bolp
(oref conf :that-buffer)
stop-converted))
(m-buffer-with-current-location
@@ -300,7 +300,7 @@ between the two buffers; we don't care which one has
comments."
stop-converted)))
;; log when we have gone long
(if (or start-in-comment stop-in-comment)
- (linked-buffer-log "In comment: %s %s"
+ (lentic-log "In comment: %s %s"
(when start-in-comment
"start")
(when stop-in-comment
@@ -311,17 +311,17 @@ between the two buffers; we don't care which one has
comments."
;; remove the line comments in the to buffer
;; if the delimitors are unmatched, then we can do nothing other than
clone.
(condition-case e
- (linked-buffer-blk-uncomment-buffer
+ (lentic-blk-uncomment-buffer
conf
;; the buffer at this point has been copied over, but is in an
;; inconsistent state (because it may have comments that it should
;; not). Still, the convertor should still work because it counts from
;; the end
- (linked-buffer-convert
+ (lentic-convert
conf
;; point-min if we know nothing else
(or start (point-min)))
- (linked-buffer-convert
+ (lentic-convert
conf
;; if we have a stop
(if stop
@@ -330,13 +330,13 @@ between the two buffers; we don't care which one has
comments."
(max stop
(+ start length-before))
(point-max)))
- (linked-buffer-that conf))
+ (lentic-that conf))
(unmatched-delimiter-error
nil))))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-commented-block-configuration))
- (linked-buffer-uncommented-block-configuration
+(defmethod lentic-invert
+ ((conf lentic-commented-block-configuration))
+ (lentic-uncommented-block-configuration
"commented-inverted"
:this-buffer (oref conf :that-buffer)
:that-buffer (oref conf :this-buffer)
@@ -344,28 +344,28 @@ between the two buffers; we don't care which one has
comments."
:comment-start (oref conf :comment-start)
:comment-stop (oref conf :comment-stop)))
-(defmethod linked-buffer-block-comment-start-regexp
- ((conf linked-buffer-commented-block-configuration))
+(defmethod lentic-block-comment-start-regexp
+ ((conf lentic-commented-block-configuration))
(concat
"\\(" (regexp-quote (oref conf :comment)) "\\)?"
(oref conf :comment-start)))
-(defmethod linked-buffer-block-comment-stop-regexp
- ((conf linked-buffer-commented-block-configuration))
+(defmethod lentic-block-comment-stop-regexp
+ ((conf lentic-commented-block-configuration))
(concat
"\\(" (regexp-quote (oref conf :comment)) "\\)?"
(oref conf :comment-stop)))
-(defmethod linked-buffer-clone
- ((conf linked-buffer-uncommented-block-configuration)
+(defmethod lentic-clone
+ ((conf lentic-uncommented-block-configuration)
&optional start stop length-before start-converted stop-converted)
- "Update the contents in the linked-buffer with comments."
- ;;(linked-buffer-log "blk-clone-comment conf):(%s)" conf)
+ "Update the contents in the lentic with comments."
+ ;;(lentic-log "blk-clone-comment conf):(%s)" conf)
(let*
((start-at-bolp
(when
(and start
- (linked-buffer-bolp
+ (lentic-bolp
(oref conf :this-buffer)
start))
(m-buffer-with-current-location
@@ -374,23 +374,23 @@ between the two buffers; we don't care which one has
comments."
(line-beginning-position))))
(start-converted (or start-at-bolp start-converted)))
(if (or start-at-bolp)
- (linked-buffer-log "In comment: %s"
+ (lentic-log "In comment: %s"
(when start-at-bolp
"start")))
(call-next-method conf start stop length-before
start-converted stop-converted)
(condition-case e
- (linked-buffer-blk-comment-buffer
+ (lentic-blk-comment-buffer
conf
;; the buffer at this point has been copied over, but is in an
;; inconsistent state (because it may have comments that it should
;; not). Still, the convertor should still work because it counts from
;; the end
- (linked-buffer-convert
+ (lentic-convert
conf
;; point-min if we know nothing else
(or start (point-min)))
- (linked-buffer-convert
+ (lentic-convert
conf
;; if we have a stop
(if stop
@@ -399,12 +399,12 @@ between the two buffers; we don't care which one has
comments."
(max stop
(+ start length-before))
(point-max)))
- (linked-buffer-that conf))
+ (lentic-that conf))
(unmatched-delimiter-error nil))))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-uncommented-block-configuration))
- (linked-buffer-commented-block-configuration
+(defmethod lentic-invert
+ ((conf lentic-uncommented-block-configuration))
+ (lentic-commented-block-configuration
"uncommented-inverted"
:this-buffer (oref conf :that-buffer)
:that-buffer (oref conf :this-buffer)
@@ -412,14 +412,14 @@ between the two buffers; we don't care which one has
comments."
:comment-start (oref conf :comment-start)
:comment-stop (oref conf :comment-stop)))
-(defmethod linked-buffer-block-comment-start-regexp
- ((conf linked-buffer-uncommented-block-configuration))
+(defmethod lentic-block-comment-start-regexp
+ ((conf lentic-uncommented-block-configuration))
(oref conf :comment-start))
-(defmethod linked-buffer-block-comment-stop-regexp
- ((conf linked-buffer-uncommented-block-configuration))
+(defmethod lentic-block-comment-stop-regexp
+ ((conf lentic-uncommented-block-configuration))
(oref conf :comment-stop))
-(provide 'linked-buffer-block)
+(provide 'lentic-block)
-;;; linked-buffer-block.el ends here
+;;; lentic-block.el ends here
diff --git a/lentic-delayed.el b/lentic-delayed.el
index fb442b3136..04f3a6d066 100644
--- a/lentic-delayed.el
+++ b/lentic-delayed.el
@@ -1,4 +1,4 @@
-;; linked-buffer-delayed.el --- linked-buffers but slowly -*- lexical-binding:
t -*-
+;; lentic-delayed.el --- lentics but slowly -*- lexical-binding: t -*-
;; This file is not part of Emacs
@@ -23,86 +23,86 @@
;;; Commentary:
;;
-;; Currently, the implementation of things like linked-buffer-block.el is
+;; Currently, the implementation of things like lentic-block.el is
;; quite slow. This is exacerbated by changes which percolate though large
;; parts of the buffer. Of course, the obvious solution would be to fix the
-;; dodgy algorithms in linked-buffer-block, but why do that when instead you
+;; dodgy algorithms in lentic-block, but why do that when instead you
;; can run the same dodgy algorithms on the idle cycle. This has the advantage
;; that multiple changes with no idle setp in between will be aggregated.
;;; Code:
-(require 'linked-buffer)
+(require 'lentic)
(require 'dash)
-(defvar linked-buffer-delayed-queue nil)
-(defvar linked-buffer-delayed-timer nil)
+(defvar lentic-delayed-queue nil)
+(defvar lentic-delayed-timer nil)
-(defun linked-buffer-delayed-ensure-timer ()
- (unless linked-buffer-delayed-timer
- (setq linked-buffer-delayed-timer
- (run-with-idle-timer 0.05 t 'linked-buffer-delayed-timer-function))))
+(defun lentic-delayed-ensure-timer ()
+ (unless lentic-delayed-timer
+ (setq lentic-delayed-timer
+ (run-with-idle-timer 0.05 t 'lentic-delayed-timer-function))))
-(defun linked-buffer-delayed-timer-function ()
- (message "linked-buffer-delayed-timer running")
+(defun lentic-delayed-timer-function ()
+ (message "lentic-delayed-timer running")
(let ((repeat t))
(while
(and repeat
- linked-buffer-delayed-queue)
- (linked-buffer-delayed-clone
- (pop linked-buffer-delayed-queue))
+ lentic-delayed-queue)
+ (lentic-delayed-clone
+ (pop lentic-delayed-queue))
;; redisplay and wait
(setq repeat (sit-for 0.1))))
;; kill timer if we have finished
- (unless linked-buffer-delayed-queue
- (cancel-timer linked-buffer-delayed-timer)
- (setq linked-buffer-delayed-timer nil)))
+ (unless lentic-delayed-queue
+ (cancel-timer lentic-delayed-timer)
+ (setq lentic-delayed-timer nil)))
-(defclass linked-buffer-delayed-configuration
- (linked-buffer-configuration)
+(defclass lentic-delayed-configuration
+ (lentic-configuration)
((delayed
:initarg :delayed))
- "Linked-buffer in the idle cycle.")
+ "lentic in the idle cycle.")
-(defmethod linked-buffer-this ((conf linked-buffer-delayed-configuration))
- (linked-buffer-this (oref conf :delayed)))
+(defmethod lentic-this ((conf lentic-delayed-configuration))
+ (lentic-this (oref conf :delayed)))
-(defmethod linked-buffer-that ((conf linked-buffer-delayed-configuration))
- (linked-buffer-that (oref conf :delayed)))
+(defmethod lentic-that ((conf lentic-delayed-configuration))
+ (lentic-that (oref conf :delayed)))
-(defmethod linked-buffer-create ((conf linked-buffer-delayed-configuration))
- (let ((buf (linked-buffer-create (oref conf :delayed))))
+(defmethod lentic-create ((conf lentic-delayed-configuration))
+ (let ((buf (lentic-create (oref conf :delayed))))
;; we should now have set up that-buffer and config, which will be the
;; undelayed form -- so swap a new one in
(with-current-buffer
- (linked-buffer-that conf)
- (setq linked-buffer-config
- (linked-buffer-delayed-configuration
+ (lentic-that conf)
+ (setq lentic-config
+ (lentic-delayed-configuration
"inverted-delayed"
- :delayed linked-buffer-config)))
+ :delayed lentic-config)))
buf))
-(defmethod linked-buffer-convert ((conf linked-buffer-delayed-configuration)
+(defmethod lentic-convert ((conf lentic-delayed-configuration)
location)
- (linked-buffer-convert (oref conf :delayed) location))
+ (lentic-convert (oref conf :delayed) location))
-(defmethod linked-buffer-clone ((conf linked-buffer-delayed-configuration))
- (add-to-list 'linked-buffer-delayed-queue
+(defmethod lentic-clone ((conf lentic-delayed-configuration))
+ (add-to-list 'lentic-delayed-queue
conf t)
- (linked-buffer-delayed-ensure-timer))
+ (lentic-delayed-ensure-timer))
-(defmethod linked-buffer-delayed-clone ((conf
- linked-buffer-delayed-configuration))
+(defmethod lentic-delayed-clone ((conf
+ lentic-delayed-configuration))
;; inhibit-modification-hooks or we percolate back to the start
(let ((inhibit-modification-hooks t))
- (linked-buffer-clone (oref conf :delayed))
- (linked-buffer-update-point (oref conf :delayed))))
+ (lentic-clone (oref conf :delayed))
+ (lentic-update-point (oref conf :delayed))))
-(defun linked-buffer-delayed-init (delayed)
- (unless linked-buffer-config
+(defun lentic-delayed-init (delayed)
+ (unless lentic-config
(funcall delayed)
- (setq linked-buffer-config
- (linked-buffer-delayed-configuration "delayed" :delayed
linked-buffer-config))))
+ (setq lentic-config
+ (lentic-delayed-configuration "delayed" :delayed lentic-config))))
-(provide 'linked-buffer-delayed)
+(provide 'lentic-delayed)
diff --git a/lentic-dev.el b/lentic-dev.el
index 4d9ca9155b..02721b4e58 100644
--- a/lentic-dev.el
+++ b/lentic-dev.el
@@ -1,19 +1,19 @@
-(require 'linked-buffer)
+(require 'lentic)
-(defvar linked-buffer-dev-insert-face 'font-lock-keyword-face)
+(defvar lentic-dev-insert-face 'font-lock-keyword-face)
-(defun linked-buffer-dev-rotate-face ()
+(defun lentic-dev-rotate-face ()
(interactive)
- (setq linked-buffer-dev-insert-face
+ (setq lentic-dev-insert-face
(nth (random (length (face-list)))
(face-list)))
(message "Insert face is now %s"
(propertize
"this"
'face
- linked-buffer-dev-insert-face)))
+ lentic-dev-insert-face)))
-(defadvice linked-buffer-insertion-string-transform
+(defadvice lentic-insertion-string-transform
(after face-transform
(string)
disable)
@@ -21,22 +21,22 @@
(propertize
string
'font-lock-face
- linked-buffer-dev-insert-face
+ lentic-dev-insert-face
'face
- linked-buffer-dev-insert-face)))
+ lentic-dev-insert-face)))
-(defvar linked-buffer-enable-insertion-marking nil)
-(defun linked-buffer-enable-insertion-marking ()
+(defvar lentic-enable-insertion-marking nil)
+(defun lentic-enable-insertion-marking ()
(interactive)
- (if linked-buffer-enable-insertion-marking
+ (if lentic-enable-insertion-marking
(progn
- (ad-deactivate 'linked-buffer-insertion-string-transform)
- (setq linked-buffer-enable-insertion-marking nil)
+ (ad-deactivate 'lentic-insertion-string-transform)
+ (setq lentic-enable-insertion-marking nil)
(message "Insertion marking off"))
- (ad-enable-advice 'linked-buffer-insertion-string-transform
+ (ad-enable-advice 'lentic-insertion-string-transform
'after 'face-transform)
- (ad-activate 'linked-buffer-insertion-string-transform)
- (setq linked-buffer-enable-insertion-marking t)
+ (ad-activate 'lentic-insertion-string-transform)
+ (setq lentic-enable-insertion-marking t)
(message "Insertion marking on")))
-(provide 'linked-buffer-dev)
+(provide 'lentic-dev)
diff --git a/lentic-latex-code.el b/lentic-latex-code.el
index 34a8d341b9..5082aa64c6 100644
--- a/lentic-latex-code.el
+++ b/lentic-latex-code.el
@@ -1,4 +1,4 @@
-;;; linked-buffer-latex-code.el -- Latex literate programming -*-
lexical-binding: t -*-
+;;; lentic-latex-code.el -- Latex literate programming -*- lexical-binding: t
-*-
;; This file is not part of Emacs
;; Author: Phillip Lord <phillip.lord@newcastle.ac.uk>
@@ -24,7 +24,7 @@
;;; Commentary:
;;
-;; A `linked-buffer-block-configuration' environment where one buffer is latex
+;; A `lentic-block-configuration' environment where one buffer is latex
;; and the other is some programming language, with code blocks marked up with
;; a \begin{code}\end{code} environment.
;;
@@ -34,10 +34,10 @@
;; author wants, by defining the code environment first.
;;; Code:
-(require 'linked-buffer-block)
+(require 'lentic-block)
-(defun linked-buffer-clojure-to-latex-new ()
- (linked-buffer-commented-block-configuration
+(defun lentic-clojure-to-latex-new ()
+ (lentic-commented-block-configuration
"lb-commented clojure latex"
:this-buffer (current-buffer)
:linked-file
@@ -48,16 +48,16 @@
:comment-start "\\\\end{code}"
:comment-stop "\\\\begin{code}"))
-(defun linked-buffer-clojure-latex-init ()
- (setq linked-buffer-config
- (linked-buffer-clojure-to-latex-new)))
+(defun lentic-clojure-latex-init ()
+ (setq lentic-config
+ (lentic-clojure-to-latex-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-clojure-latex-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-clojure-latex-init)
-(defun linked-buffer-latex-to-clojure-new ()
- (linked-buffer-uncommented-block-configuration
+(defun lentic-latex-to-clojure-new ()
+ (lentic-uncommented-block-configuration
"lb-commented latex clojure"
:this-buffer (current-buffer)
:linked-file
@@ -68,24 +68,24 @@
:comment-start "\\\\end{code}"
:comment-stop "\\\\begin{code}"))
-(defun linked-buffer-latex-clojure-init ()
- (setq linked-buffer-config
- (linked-buffer-latex-to-clojure-new)))
+(defun lentic-latex-clojure-init ()
+ (setq lentic-config
+ (lentic-latex-to-clojure-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-clojure-latex-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-clojure-latex-init)
-(defun linked-buffer-clojure-latex-delayed-init ()
- (linked-buffer-delayed-init 'linked-buffer-clojure-latex-init))
+(defun lentic-clojure-latex-delayed-init ()
+ (lentic-delayed-init 'lentic-clojure-latex-init))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-clojure-latex-delayed-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-clojure-latex-delayed-init)
-(provide 'linked-buffer-latex-code)
+(provide 'lentic-latex-code)
-;;; linked-buffer-latex-code ends here
+;;; lentic-latex-code ends here
diff --git a/lentic-org.el b/lentic-org.el
index 7fd00a06a7..c2a53f426d 100644
--- a/lentic-org.el
+++ b/lentic-org.el
@@ -1,4 +1,4 @@
-;;; linked-buffer-org.el --- org support for linked-buffer -*-
lexical-binding: t -*-
+;;; lentic-org.el --- org support for lentic -*- lexical-binding: t -*-
;;; Header:
@@ -26,7 +26,7 @@
;;; Commentary:
-;; This file provides linked-buffer for org and emacs-lisp files. This enables
a
+;; This file provides lentic for org and emacs-lisp files. This enables a
;; literate form of programming with Elisp, using org mode to provide
;; documentation mark up.
@@ -35,7 +35,7 @@
;; between the two modes.
;; #+BEGIN_SRC emacs-lisp
-(require 'linked-buffer-block)
+(require 'lentic-block)
;; #+END_SRC
@@ -57,19 +57,19 @@
;; file-local variables. This is a particular issue if setting
`lexical-binding'.
;; In a literate org file, this might appear on the first line of the
;; embedded lisp, but it will *not* appear in first line of an emacs-lisp
-;; linked-buffer, so the file will be interpreted with dynamic binding.
+;; lentic, so the file will be interpreted with dynamic binding.
;; *** Implementation
-;; The implementation is a straight-forward use of `linked-buffer-block' with
+;; The implementation is a straight-forward use of `lentic-block' with
;; regexps for org source blocks. It currently takes no account of
;; org-mode :tangle directives -- so all lisp in the buffer will be present in
-;; the emacs-lisp mode linked-buffer.
+;; the emacs-lisp mode lentic.
;; #+BEGIN_SRC emacs-lisp
-(defun linked-buffer-org-to-el-new ()
- (linked-buffer-uncommented-block-configuration
+(defun lentic-org-to-el-new ()
+ (lentic-uncommented-block-configuration
"lb-org-to-el"
:this-buffer (current-buffer)
:linked-file
@@ -81,15 +81,15 @@
:comment-stop "#\\\+BEGIN_SRC emacs-lisp"
:comment-start "#\\\+END_SRC"))
-(defun linked-buffer-org-el-init ()
- (setq linked-buffer-config
- (linked-buffer-org-to-el-new)))
+(defun lentic-org-el-init ()
+ (setq lentic-config
+ (lentic-org-to-el-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-org-el-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-org-el-init)
-(defun linked-buffer-el-to-org-new ()
- (linked-buffer-commented-block-configuration
+(defun lentic-el-to-org-new ()
+ (lentic-commented-block-configuration
"lb-el-to-org"
:this-buffer (current-buffer)
:linked-file
@@ -101,12 +101,12 @@
:comment-stop "#\\\+BEGIN_SRC emacs-lisp"
:comment-start "#\\\+END_SRC"))
-(defun linked-buffer-el-org-init ()
- (setq linked-buffer-config
- (linked-buffer-el-to-org-new)))
+(defun lentic-el-org-init ()
+ (setq lentic-config
+ (lentic-el-to-org-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-el-org-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-el-org-init)
;; #+END_SRC
@@ -152,8 +152,8 @@
;; You may also wish to add a ";;; Footer:" heading as well.
;; Secondly, mark *all* of the code with org-mode source demarks. Finally, set
-;; `linked-buffer-init' to `linked-buffer-orgel-org-init' (normally with a
-;; file-local or dir-local variable). Now linked-buffer can be started. The
+;; `lentic-init' to `lentic-orgel-org-init' (normally with a
+;; file-local or dir-local variable). Now lentic can be started. The
;; header will appear as normal text in the org-mode buffer, with all other
;; comments inside a source block. You can now move through the buffer
splitting
;; the source block (with `org-babel-demarcate-block' which has to win a prize
@@ -167,7 +167,7 @@
;; fix would be to add some functionality like `org-babel-demarcate-block' to
;; emacs-lisp-mode. Even better would to automatically add source markup when
"("
;; was pressed at top level (if paredit were active, then it would also be
-;; obvious where to put the close). Finally, have both `linked-buffer-org' and
+;; obvious where to put the close). Finally, have both `lentic-org' and
;; `org-mode' just recognise emacs-lisp as a source entity *without* any
further
;; markup.
@@ -205,12 +205,12 @@
;; seems consistent with emacs-lisp usage.
;; #+BEGIN_SRC emacs-lisp
-(defclass linked-buffer-org-to-orgel-configuration
- (linked-buffer-uncommented-block-configuration)
+(defclass lentic-org-to-orgel-configuration
+ (lentic-uncommented-block-configuration)
())
-(defmethod linked-buffer-clone
- ((conf linked-buffer-org-to-orgel-configuration)
+(defmethod lentic-clone
+ ((conf lentic-org-to-orgel-configuration)
&optional start stop length-before
start-converted stop-converted)
;; do everything else to the buffer
@@ -222,7 +222,7 @@
start-converted stop-converted)
(m-buffer-replace-match
(m-buffer-match
- (linked-buffer-that conf)
+ (lentic-that conf)
;; we can be in one of two states depending on whether we have made a new
;; clone or an incremental change
"^;; \\(;;;\\|# #\\)"
@@ -230,39 +230,39 @@
(cadr
(car
(m-buffer-match-line
- (linked-buffer-that conf)))))
+ (lentic-that conf)))))
";;;")
;; replace big headers, in either of their two states
(m-buffer-replace-match
(m-buffer-match
- (linked-buffer-that conf)
+ (lentic-that conf)
"^;; [*] \\(\\w*\\)$"
:begin
(cadr
(car
(m-buffer-match-line
- (linked-buffer-that conf)))))
+ (lentic-that conf)))))
";;; \\1:")
(m-buffer-replace-match
- (m-buffer-match (linked-buffer-that conf)
+ (m-buffer-match (lentic-that conf)
"^;; ;;; \\(\\w*:\\)$"
:begin
(cadr
(car
(m-buffer-match-line
- (linked-buffer-that conf)))))
+ (lentic-that conf)))))
";;; \\1"))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-org-to-orgel-configuration))
+(defmethod lentic-invert
+ ((conf lentic-org-to-orgel-configuration))
(let ((rtn
- (linked-buffer-orgel-to-org-new)))
+ (lentic-orgel-to-org-new)))
(oset rtn :that-buffer
- (linked-buffer-this conf))
+ (lentic-this conf))
rtn))
-(defun linked-buffer-org-to-orgel-new ()
- (linked-buffer-org-to-orgel-configuration
+(defun lentic-org-to-orgel-new ()
+ (lentic-org-to-orgel-configuration
"lb-orgel-to-el"
:this-buffer (current-buffer)
:linked-file
@@ -274,12 +274,12 @@
:comment-stop "#\\\+BEGIN_SRC emacs-lisp"
:comment-start "#\\\+END_SRC"))
-(defun linked-buffer-org-orgel-init ()
- (setq linked-buffer-config
- (linked-buffer-org-to-orgel-new)))
+(defun lentic-org-orgel-init ()
+ (setq lentic-config
+ (lentic-org-to-orgel-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-org-orgel-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-org-orgel-init)
;; #+END_SRC
;; **** orgel->org
@@ -290,41 +290,41 @@
;; #+BEGIN_SRC emacs-lisp
-(defclass linked-buffer-orgel-to-org-configuration
- (linked-buffer-commented-block-configuration)
+(defclass lentic-orgel-to-org-configuration
+ (lentic-commented-block-configuration)
())
-(defmethod linked-buffer-clone
- ((conf linked-buffer-orgel-to-org-configuration)
+(defmethod lentic-clone
+ ((conf lentic-orgel-to-org-configuration)
&optional start stop length-before start-converted stop-converted)
;; do everything else to the buffer
(call-next-method conf start stop length-before
start-converted stop-converted)
(m-buffer-replace-match
(m-buffer-match
- (linked-buffer-that conf)
+ (lentic-that conf)
";;; "
:end
;; we matching a lot of lines for one line here...
(cadr
(car
(m-buffer-match-line
- (linked-buffer-that conf)))))
+ (lentic-that conf)))))
"# # ")
(m-buffer-replace-match
- (m-buffer-match (linked-buffer-that conf)
+ (m-buffer-match (lentic-that conf)
"^;;; \\(\\\w*\\):")
"* \\1"))
-(defmethod linked-buffer-invert
- ((conf linked-buffer-orgel-to-org-configuration))
+(defmethod lentic-invert
+ ((conf lentic-orgel-to-org-configuration))
(let ((rtn
- (linked-buffer-org-to-orgel-new)))
- (oset rtn :that-buffer (linked-buffer-this conf))
+ (lentic-org-to-orgel-new)))
+ (oset rtn :that-buffer (lentic-this conf))
rtn))
-(defun linked-buffer-orgel-to-org-new ()
- (linked-buffer-orgel-to-org-configuration
+(defun lentic-orgel-to-org-new ()
+ (lentic-orgel-to-org-configuration
"lb-orgel-to-org"
:this-buffer (current-buffer)
;; we don't really need a file and could cope without, but org mode assumes
@@ -339,12 +339,12 @@
:comment-stop "#\\\+BEGIN_SRC emacs-lisp"
:comment-start "#\\\+END_SRC"))
-(defun linked-buffer-orgel-org-init ()
- (setq linked-buffer-config
- (linked-buffer-orgel-to-org-new)))
+(defun lentic-orgel-org-init ()
+ (setq lentic-config
+ (lentic-orgel-to-org-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-orgel-org-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-orgel-org-init)
;; #+END_SRC
@@ -354,8 +354,8 @@
;; *** org->clojure
;; #+BEGIN_SRC emacs-lisp
-(defun linked-buffer-org-to-clojure-new ()
- (linked-buffer-uncommented-block-configuration
+(defun lentic-org-to-clojure-new ()
+ (lentic-uncommented-block-configuration
"lb-org-to-clojure"
:this-buffer (current-buffer)
:linked-file
@@ -370,15 +370,15 @@
;; will be ignored. Probably we should count instead!
:case-fold-search nil))
-(defun linked-buffer-org-clojure-init ()
- (setq linked-buffer-config
- (linked-buffer-org-to-clojure-new)))
+(defun lentic-org-clojure-init ()
+ (setq lentic-config
+ (lentic-org-to-clojure-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-org-clojure-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-org-clojure-init)
-(defun linked-buffer-clojure-to-org-new ()
- (linked-buffer-commented-block-configuration
+(defun lentic-clojure-to-org-new ()
+ (lentic-commented-block-configuration
"lb-clojure-to-org"
:this-buffer (current-buffer)
:linked-file
@@ -390,27 +390,27 @@
:comment-stop "#\\\+BEGIN_SRC clojure"
:comment-start "#\\\+END_SRC"))
-(defun linked-buffer-clojure-org-init ()
- (setq linked-buffer-config
- (linked-buffer-clojure-to-org-new)))
+(defun lentic-clojure-org-init ()
+ (setq lentic-config
+ (lentic-clojure-to-org-new)))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-clojure-org-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-clojure-org-init)
;; #+END_SRC
;;; Footer:
;; Declare the end of the file, and add file-local support for orgel->org
-;; transformation. Do not use linked-buffers on this file while changing the
+;; transformation. Do not use lentics on this file while changing the
;; lisp in the file without backing up first!
;; #+BEGIN_SRC emacs-lisp
-(provide 'linked-buffer-org)
-;;; linked-buffer-org.el ends here
+(provide 'lentic-org)
+;;; lentic-org.el ends here
;; #+END_SRC
;; # Local Variables:
-;; # linked-buffer-init: linked-buffer-orgel-org-init
+;; # lentic-init: lentic-orgel-org-init
;; # End:
diff --git a/lentic.el b/lentic.el
index f2c88c3a0b..ea5d5f584c 100644
--- a/lentic.el
+++ b/lentic.el
@@ -1,4 +1,4 @@
-;;; linked-buffer.el --- One buffer as a view of another -*- lexical-binding:
t -*-
+;;; lentic.el --- One buffer as a view of another -*- lexical-binding: t -*-
;;; Header:
@@ -28,14 +28,14 @@
;;; Commentary:
-;; Linked-buffers enables simultaneous editing and viewing of the same (or
+;; lentics enables simultaneous editing and viewing of the same (or
;; closely related) text in two or more buffers, potentially in different
modes.
;; Sometimes, it would be nice to edit a file in two ways at once. For
instance,
;; you might have a source file in a computational language with richly marked
;; documentation. As Emacs is a modal editor, it would be nice to edit this
file
;; both in a mode for the computational language and for the marked up
-;; documentation.
+;; documentation.
;; One solution to this is to use a single-mode which supports both types of
;; editing. The problem with this is that it is fundamentally difficult to
@@ -53,29 +53,29 @@
;; to switch modes, you simply switch buffers. The content, location of point,
;; and view are shared.
-;; However, linked-buffers can also perform a bi-directional transformation
+;; However, lentics can also perform a bi-directional transformation
;; between the two. If this is done, then the two can have different but
related
;; text. It is possible to configure the transformation for any two buffers in
a
;; extensible way, although mostly we have concentrated on mode-specific
;; configuration.
-;; The main user entry point is through `global-linked-buffer-start-mode' which
-;; provides tools to create new a new linked-buffer.
+;; The main user entry point is through `global-lentic-start-mode' which
+;; provides tools to create new a new lentic.
;;; Configuration:
-;; linked-buffers are configurable in a large number of ways. It is possible
+;; lentics are configurable in a large number of ways. It is possible
;; to control the nature of the transformation, the default buffer name that a
-;; linked-buffer takes, and the file location (or not) of the linked-buffer.
-;; For this release of linked-buffer currently, each buffer can only be linked
+;; lentic takes, and the file location (or not) of the lentic.
+;; For this release of lentic currently, each buffer can only be linked
;; to a single buffer, although this restriction will be removed in later
;; versions.
;; Configuration of a buffer happens in one of two places. First,
-;; `linked-buffer-init' is run when a linked-buffer is first created. This
-;; function should set the actual configuration `linked-buffer-config', and is
+;; `lentic-init' is run when a lentic is first created. This
+;; function should set the actual configuration `lentic-config', and is
;; mostly designed for use as a file-local or dir-local variable. All
subsequent
-;; configuration happens through `linked-buffer-config' which is an EIEIO
object
+;; configuration happens through `lentic-config' which is an EIEIO object
;; and associated methods.
;; There are now a number of different configurations, which can be used for
@@ -89,7 +89,7 @@
;; demarcated by start and end tags, and everything else is commented by
;; line-start comments. Comments are added or removed between the two
buffers.
-;; The second of these is extended in linked-buffer-org.el to provide the
+;; The second of these is extended in lentic-org.el to provide the
;; configuration for this file: there is a normal emacs-lisp file in one buffer
;; and an org-mode version in another. Other programmatic and documentation
modes
;; are supported in other files.
@@ -108,7 +108,7 @@
;; The current implementation is crude -- currently, the entire buffer is
copied
;; on every change event. For large buffer, this comes with a significant
;; performance penalty, although for modern computers "large" means "pretty
big".
-;; One solution to this is offered by `linked-buffer-delayed-configuration';
this
+;; One solution to this is offered by `lentic-delayed-configuration'; this
;; performs the copying in the idle cycle and, as a side-effect, amalgamates
;; multiple changes into a single copy. As a second problem when switching
;; buffers rapidly, it can effectively break the undo mechanism -- or at
least, I
@@ -121,37 +121,38 @@
;; ** State
;; This section defines all of the variables that the basic state for
-;; linked-buffer is stored in. We deliberately have as few of these as
possible,
+;; lentic is stored in. We deliberately have as few of these as possible,
;; as this makes re-initializing the state during development as
straight-forward
;; as possible.
;; #+BEGIN_SRC emacs-lisp
(require 'eieio)
+(require 'm-buffer)
-(defvar linked-buffer-init 'linked-buffer-default-init
- "Function that initializes a linked-buffer.
-This should set up `linked-buffer-config' appropriately.")
+(defvar lentic-init 'lentic-default-init
+ "Function that initializes a lentic.
+This should set up `lentic-config' appropriately.")
;; In future versions, this may get turned into a list so that we can have
;; multiple linked buffers, but it is not clear how the user interface
-;; functions such as `linked-buffer-swap-window' would work now.
-(defvar linked-buffer-config nil
- "Configuration for linked-buffer.
+;; functions such as `lentic-swap-window' would work now.
+(defvar lentic-config nil
+ "Configuration for lentic.
-This is object created by function linked-buffer-configuration',
+This is object created by function lentic-configuration',
which defines the way in which the text in the different buffers
is kept synchronized. This configuration is resiliant to changes
of mode in the current buffer.")
-(make-variable-buffer-local 'linked-buffer-config)
-(put 'linked-buffer-config 'permanent-local t)
+(make-variable-buffer-local 'lentic-config)
+(put 'lentic-config 'permanent-local t)
-(defvar linked-buffer-init-functions nil
- "A list of all functions that can be used as linked-buffer-init
+(defvar lentic-init-functions nil
+ "A list of all functions that can be used as lentic-init
functions.")
-(defun linked-buffer-config-name (buffer)
+(defun lentic-config-name (buffer)
"Given BUFFER, return a name for the configuration object."
(format "linked: %s" buffer))
;; #+end_src
@@ -159,14 +160,14 @@ of mode in the current buffer.")
;; ** Base Configuration
;; This section defines the base class and generic methods for all
-;; linked-buffer-configuration objects.
+;; lentic-configuration objects.
;; #+begin_src emacs-lisp
;;
;; Base Configuration:
;;
-(defclass linked-buffer-configuration ()
+(defclass lentic-configuration ()
((this-buffer
:initarg :this-buffer)
(that-buffer
@@ -180,24 +181,24 @@ of mode in the current buffer.")
(last-change-stop-converted
:initarg :last-change-stop-converted
:initform nil))
- "Configuration object for linked-buffer, which defines the mechanism
+ "Configuration object for lentic, which defines the mechanism
by which linking happens.")
-(defgeneric linked-buffer-create (conf))
-(defgeneric linked-buffer-convert (conf location))
-(defgeneric linked-buffer-invert (conf that-buffer))
+(defgeneric lentic-create (conf))
+(defgeneric lentic-convert (conf location))
+(defgeneric lentic-invert (conf that-buffer))
-(defmethod linked-buffer-this ((conf linked-buffer-configuration))
+(defmethod lentic-this ((conf lentic-configuration))
(oref conf :this-buffer))
-(defmethod linked-buffer-that ((conf linked-buffer-configuration))
+(defmethod lentic-that ((conf lentic-configuration))
(oref conf :that-buffer))
-(defmethod linked-buffer-ensure-that ((conf linked-buffer-configuration))
- "Get the linked-buffer for this configuration
+(defmethod lentic-ensure-that ((conf lentic-configuration))
+ "Get the lentic for this configuration
or create it if it does not exist."
- (or (linked-buffer-that conf)
- (linked-buffer-create conf)))
+ (or (lentic-that conf)
+ (lentic-create conf)))
;; #+end_src
@@ -209,32 +210,32 @@ or create it if it does not exist."
;; #+begin_src emacs-lisp
-(defclass linked-buffer-default-configuration (linked-buffer-configuration)
+(defclass lentic-default-configuration (lentic-configuration)
((linked-file
:initform nil
:initarg :linked-file)
(linked-mode
:initform 'normal-mode
:initarg :linked-mode))
- "Configuration which maintains two linked-buffers with the same contents.")
+ "Configuration which maintains two lentics with the same contents.")
-(defun linked-buffer-insertion-string-transform (string)
+(defun lentic-insertion-string-transform (string)
"Transform the string that is about to be inserted.
This function is not meant to do anything. It's useful to
advice."
string)
-(defmethod linked-buffer-create ((conf linked-buffer-default-configuration))
- "Create the linked-buffer for this configuration.
-Given a `linked-buffer-configuration' object, create the linked-buffer
+(defmethod lentic-create ((conf lentic-default-configuration))
+ "Create the lentic for this configuration.
+Given a `lentic-configuration' object, create the lentic
appropriate for that configurationuration. It is the callers
responsibility to check that buffer has not already been
created."
;; make sure the world is ready for linked buffers
- (linked-buffer-ensure-hooks)
- ;; create linked-buffer
+ (lentic-ensure-hooks)
+ ;; create lentic
(let* ((this-buffer
- (linked-buffer-this conf))
+ (lentic-this conf))
(that-buffer
(get-buffer-create
(format "*linked: %s*"
@@ -245,7 +246,7 @@ created."
;; make sure this-buffer knows about that-buffer
(oset conf :that-buffer that-buffer)
;; insert the contents
- (linked-buffer-update-contents conf)
+ (lentic-update-contents conf)
;; init that-buffer with mode, file and config
;; the mode must be init'd after adding content in case there are any
;; file-local variables need to be evaled
@@ -254,23 +255,23 @@ created."
(funcall sec-mode))
(when sec-file
(set-visited-file-name sec-file))
- (setq linked-buffer-config
- (linked-buffer-invert conf)))
+ (setq lentic-config
+ (lentic-invert conf)))
that-buffer))
-(defmethod linked-buffer-invert ((conf linked-buffer-default-configuration))
- (linked-buffer-default-configuration
- (linked-buffer-config-name (linked-buffer-that conf))
+(defmethod lentic-invert ((conf lentic-default-configuration))
+ (lentic-default-configuration
+ (lentic-config-name (lentic-that conf))
:this-buffer (oref conf :that-buffer)
:that-buffer (oref conf :this-buffer)))
-(defmethod linked-buffer-convert ((conf linked-buffer-default-configuration)
+(defmethod lentic-convert ((conf lentic-default-configuration)
location)
"For this configuration, convert LOCATION to an equivalent location in
-the linked-buffer."
+the lentic."
location)
-(defmethod linked-buffer-clone ((conf linked-buffer-configuration)
+(defmethod lentic-clone ((conf lentic-configuration)
&optional start stop _length-before
start-converted stop-converted)
"Updates that-buffer to reflect the contents in this-buffer.
@@ -279,11 +280,11 @@ Currently, this is just a clone all method but may use
regions in future."
(let ((this-b (oref conf :this-buffer))
(that-b (oref conf :that-buffer)))
(with-current-buffer this-b
- ;;(linked-buffer-log "this-b (point,start,stop)(%s,%s,%s)" (point) start
stop)
+ ;;(lentic-log "this-b (point,start,stop)(%s,%s,%s)" (point) start stop)
(let* ((start (or start (point-min)))
(stop (or stop (point-max)))
;; get the start location that we converted before the change.
- ;; linked-buffer-convert is not reliable now, because the two
+ ;; lentic-convert is not reliable now, because the two
;; buffers do not share state until we have percolated it
(converted-start
(or start-converted
@@ -304,20 +305,20 @@ Currently, this is just a clone all method but may use
regions in future."
(widen)
;; want to see where it goes
;; hence the property
- (linked-buffer-insertion-string-transform
+ (lentic-insertion-string-transform
(buffer-substring-no-properties
start stop)))))))))))
-(defun linked-buffer-default-init ()
+(defun lentic-default-init ()
"Default init function.
-See `linked-buffer-init' for details."
- (setq linked-buffer-config
- (linked-buffer-default-configuration
- (linked-buffer-config-name (current-buffer))
+See `lentic-init' for details."
+ (setq lentic-config
+ (lentic-default-configuration
+ (lentic-config-name (current-buffer))
:this-buffer (current-buffer))))
-(add-to-list 'linked-buffer-init-functions
- 'linked-buffer-default-init)
+(add-to-list 'lentic-init-functions
+ 'lentic-default-init)
;; #+end_src
@@ -327,52 +328,52 @@ See `linked-buffer-init' for details."
;; Hooks into Emacs change system, some basic window management tools and so
on.
;; #+begin_src emacs-lisp
-(defmacro linked-buffer-when-linked (&rest body)
- "Evaluate BODY when in a linked-buffer."
+(defmacro lentic-when-linked (&rest body)
+ "Evaluate BODY when in a lentic."
(declare (debug let))
`(when (and
- linked-buffer-config
- (linked-buffer-that
- linked-buffer-config)
+ lentic-config
+ (lentic-that
+ lentic-config)
(buffer-live-p
- (linked-buffer-that
- linked-buffer-config)))
+ (lentic-that
+ lentic-config)))
,@body))
-(defun linked-buffer-ensure-hooks ()
+(defun lentic-ensure-hooks ()
"Ensures that the hooks that this mode requires are in place."
(add-hook 'post-command-hook
- 'linked-buffer-post-command-hook)
+ 'lentic-post-command-hook)
;; after and before-change functions are hooks (with args) even if they are
;; not named as such.
(add-hook 'after-change-functions
- 'linked-buffer-after-change-function)
+ 'lentic-after-change-function)
(add-hook 'before-change-functions
- 'linked-buffer-before-change-function)
+ 'lentic-before-change-function)
(add-hook 'after-save-hook
- 'linked-buffer-after-save-hook))
+ 'lentic-after-save-hook))
-(defvar linked-buffer-log t)
-(defmacro linked-buffer-log (&rest rest)
+(defvar lentic-log t)
+(defmacro lentic-log (&rest rest)
"Log REST."
- `(when linked-buffer-log
- (linked-buffer-when-linked
+ `(when lentic-log
+ (lentic-when-linked
(let ((msg
(concat
(format ,@rest)
"\n")))
(with-current-buffer
- (get-buffer-create "*linked-buffer-log*")
+ (get-buffer-create "*lentic-log*")
(goto-char (point-max))
(insert msg))))))
-(defvar linked-buffer-emergency nil
- "Iff linked-buffer-emergency is non-nil stop all change related
+(defvar lentic-emergency nil
+ "Iff lentic-emergency is non-nil stop all change related
activity.
-This is not the same as disabling linked-buffer mode. It stops
-all linked-buffer related activity in all buffers; normally this
-happens as a result of an error condition. If linked-buffer was
+This is not the same as disabling lentic mode. It stops
+all lentic related activity in all buffers; normally this
+happens as a result of an error condition. If lentic was
to carry on in these circumstances, serious data loss could
occur. In normal use, this variable will only be set as a result
of a problem with the code; it is not recoverable from a user
@@ -382,96 +383,96 @@ It is useful to toggle this state on during development.
Once
enabled, buffers will not update automaticaly but only when
explicitly told to. This is much easier than try to debug errors
happening on the after-change-hooks. The
-`linked-buffer-emergency' and `linked-buffer-unemergency' hooks
+`lentic-emergency' and `lentic-unemergency' hooks
enable this.")
-(defvar linked-buffer-emergency-debug nil
- "Iff non-nil, linked-buffer will store change data, even
-during a `linked-buffer-emergency'.
+(defvar lentic-emergency-debug nil
+ "Iff non-nil, lentic will store change data, even
+during a `lentic-emergency'.
-Normally, `linked-buffer-emergency' disables all activity, but this makes
-testing incremental changes charge. With this variable set, linked-buffer will
+Normally, `lentic-emergency' disables all activity, but this makes
+testing incremental changes charge. With this variable set, lentic will
attempt to store enough change data to operate manually. This does require
-running some linked-buffer code (notably `linked-buffer-convert'). This is low
+running some lentic code (notably `lentic-convert'). This is low
risk code, but may still be buggy, and so setting this variable can cause
repeated errors.")
-(defun linked-buffer-emergency ()
- "Stop linked-buffer from working due to code problem."
+(defun lentic-emergency ()
+ "Stop lentic from working due to code problem."
(interactive)
- (setq linked-buffer-emergency t))
+ (setq lentic-emergency t))
-(defun linked-buffer-unemergency ()
- "Start linked-buffer working after stop due to code problem."
+(defun lentic-unemergency ()
+ "Start lentic working after stop due to code problem."
(interactive)
- (setq linked-buffer-emergency nil))
+ (setq lentic-emergency nil))
-(defvar linked-buffer-saving-p nil)
+(defvar lentic-saving-p nil)
-(defun linked-buffer-after-save-hook ()
- (linked-buffer-when-linked
+(defun lentic-after-save-hook ()
+ (lentic-when-linked
;; don't want to recurse!
- (when (not linked-buffer-saving-p)
- (let ((linked-buffer-saving-p t))
+ (when (not lentic-saving-p)
+ (let ((lentic-saving-p t))
(with-current-buffer
- (linked-buffer-that linked-buffer-config)
+ (lentic-that lentic-config)
(when (buffer-file-name)
(save-buffer)))))))
-(defun linked-buffer-post-command-hook ()
+(defun lentic-post-command-hook ()
"Update point according to config, with error handling."
;;(message "Entering post-command-hook")
- (unless linked-buffer-emergency
+ (unless lentic-emergency
(condition-case err
- (linked-buffer-post-command-hook-1)
+ (lentic-post-command-hook-1)
(error
- (linked-buffer-hook-fail err "post-command-hook")))))
+ (lentic-hook-fail err "post-command-hook")))))
-(defun linked-buffer-post-command-hook-1 ()
+(defun lentic-post-command-hook-1 ()
"Update point according to config."
(progn
- (linked-buffer-when-linked
- (linked-buffer-update-point linked-buffer-config))))
+ (lentic-when-linked
+ (lentic-update-point lentic-config))))
-(defun linked-buffer-hook-fail (err hook)
+(defun lentic-hook-fail (err hook)
"Give an informative message when we have to fail.
ERR is the error. HOOK is the hook type."
- (message "linked-buffer mode has failed on %s hook: %s "
+ (message "lentic mode has failed on %s hook: %s "
hook (error-message-string err))
- (linked-buffer-emergency)
- (with-output-to-temp-buffer "*linked-buffer-fail*"
- (princ "There has been an error in linked-buffer-mode.\n")
+ (lentic-emergency)
+ (with-output-to-temp-buffer "*lentic-fail*"
+ (princ "There has been an error in lentic-mode.\n")
(princ "The following is debugging information\n\n")
(princ (error-message-string err)))
- (select-window (get-buffer-window "*linked-buffer-fail*")))
+ (select-window (get-buffer-window "*lentic-fail*")))
-(defun linked-buffer-move-linked-window ()
- "Move the linked-buffer into the current window.
-If the linked-buffer is currently being displayed in another
+(defun lentic-move-linked-window ()
+ "Move the lentic into the current window.
+If the lentic is currently being displayed in another
window, then the current-buffer will be moved into that window.
-See also `linked-buffer-swap-buffer-windows'."
+See also `lentic-swap-buffer-windows'."
(interactive)
(let ((before-window-start
(window-start (get-buffer-window)))
(before-window-point
(point)))
- (linked-buffer-swap-buffer-windows
+ (lentic-swap-buffer-windows
(current-buffer)
- (linked-buffer-that linked-buffer-config))
+ (lentic-that lentic-config))
(set-window-start
(selected-window)
before-window-start)
(goto-char before-window-point)))
-(defun linked-buffer-swap-linked-window ()
- "Swap the window of the buffer and linked-buffer.
+(defun lentic-swap-linked-window ()
+ "Swap the window of the buffer and lentic.
If both are current displayed, swap the windows they
are displayed in, which keeping current buffer.
-See also `linked-buffer-move-linked-window'."
+See also `lentic-move-linked-window'."
(interactive)
- (linked-buffer-swap-buffer-windows
+ (lentic-swap-buffer-windows
(current-buffer)
- (linked-buffer-that linked-buffer-config))
+ (lentic-that lentic-config))
(when (window-live-p
(get-buffer-window
(current-buffer)))
@@ -479,7 +480,7 @@ See also `linked-buffer-move-linked-window'."
(get-buffer-window
(current-buffer)))))
-(defun linked-buffer-swap-buffer-windows (a b)
+(defun lentic-swap-buffer-windows (a b)
"Swaps the window that two buffers are displayed in.
A and B are the buffers."
(let ((window-a (get-buffer-window a))
@@ -491,75 +492,75 @@ A and B are the buffers."
(set-window-buffer
window-b a))))
-(defun linked-buffer-ensure-init ()
- "Ensure that the `linked-buffer-init' has been run."
- (unless (and linked-buffer-config
+(defun lentic-ensure-init ()
+ "Ensure that the `lentic-init' has been run."
+ (unless (and lentic-config
(slot-boundp
- linked-buffer-config :that-buffer)
- (buffer-live-p (linked-buffer-that
- linked-buffer-config)))
- (funcall linked-buffer-init)))
+ lentic-config :that-buffer)
+ (buffer-live-p (lentic-that
+ lentic-config)))
+ (funcall lentic-init)))
-(defun linked-buffer-init-create ()
- "Create the linked-buffer for current-buffer."
- (linked-buffer-ensure-init)
- (linked-buffer-create linked-buffer-config))
+(defun lentic-init-create ()
+ "Create the lentic for current-buffer."
+ (lentic-ensure-init)
+ (lentic-create lentic-config))
-(defun linked-buffer-create-in-selected-window ()
+(defun lentic-create-in-selected-window ()
"Create a linked buffer and move it to the current window."
(interactive)
(let ((before-window-start
(window-start (get-buffer-window)))
(before-window-point
(point)))
- (linked-buffer-ensure-init)
+ (lentic-ensure-init)
(set-window-buffer
(selected-window)
- (linked-buffer-create linked-buffer-config))
+ (lentic-create lentic-config))
(set-window-start
(selected-window)
before-window-start)
(goto-char before-window-point)))
-(defun linked-buffer-split-window-below ()
+(defun lentic-split-window-below ()
"Create a linked buffer in a new window below."
(interactive)
- (linked-buffer-ensure-init)
+ (lentic-ensure-init)
(set-window-buffer
(split-window-below)
- (linked-buffer-create linked-buffer-config)))
+ (lentic-create lentic-config)))
-(defun linked-buffer-split-window-right ()
+(defun lentic-split-window-right ()
"Create a linked buffer in a new window right."
(interactive)
- (linked-buffer-ensure-init)
+ (lentic-ensure-init)
(set-window-buffer
(split-window-right)
- (linked-buffer-create linked-buffer-config)))
+ (lentic-create lentic-config)))
-(defvar linked-buffer-emergency-last-change nil)
-(make-variable-buffer-local 'linked-buffer-emergency-last-change)
+(defvar lentic-emergency-last-change nil)
+(make-variable-buffer-local 'lentic-emergency-last-change)
-(defun linked-buffer-after-change-function (start stop length-before)
- "Run change update according to `linked-buffer-config'.
+(defun lentic-after-change-function (start stop length-before)
+ "Run change update according to `lentic-config'.
Errors are handled. REST is currently just ignored."
;; store values in case we want to use them
- (when linked-buffer-emergency-debug
- (setq linked-buffer-emergency-last-change (list start stop length-before)))
- (unless linked-buffer-emergency
+ (when lentic-emergency-debug
+ (setq lentic-emergency-last-change (list start stop length-before)))
+ (unless lentic-emergency
(condition-case err
- (linked-buffer-after-change-function-1 start stop length-before)
+ (lentic-after-change-function-1 start stop length-before)
(error
- (linked-buffer-hook-fail err "after change")))))
+ (lentic-hook-fail err "after change")))))
-(defun linked-buffer-after-change-function-1 (start stop length-before)
- "Run change update according to `linked-buffer-config'.
+(defun lentic-after-change-function-1 (start stop length-before)
+ "Run change update according to `lentic-config'.
REST is currently just ignored."
- (linked-buffer-when-linked
- (linked-buffer-log
+ (lentic-when-linked
+ (lentic-log
"After-change (start, stop, length-before): %s,%s,%s"
start stop length-before)
- (linked-buffer-update-contents linked-buffer-config
+ (lentic-update-contents lentic-config
start stop length-before)))
@@ -568,35 +569,35 @@ REST is currently just ignored."
;; change, this-buffer and that-buffer will have different contents
;; (until the change has been percolated). and the convert function
;; may not work properly under these circumstances.
-(defun linked-buffer-before-change-function (start stop)
+(defun lentic-before-change-function (start stop)
"Run before change update."
(unless (and
- linked-buffer-emergency
- (not linked-buffer-emergency-debug))
+ lentic-emergency
+ (not lentic-emergency-debug))
(condition-case err
(progn
- (linked-buffer-when-linked
- (oset linked-buffer-config
+ (lentic-when-linked
+ (oset lentic-config
:last-change-start-converted
- (linked-buffer-convert
- linked-buffer-config
+ (lentic-convert
+ lentic-config
start))
- (oset linked-buffer-config
+ (oset lentic-config
:last-change-stop-converted
- (linked-buffer-convert
- linked-buffer-config
+ (lentic-convert
+ lentic-config
stop)))
- (linked-buffer-log
+ (lentic-log
"Before change:(%s,%s,%s,%s)"
start stop
- (oref linked-buffer-config
+ (oref lentic-config
:last-change-start-converted)
- (oref linked-buffer-config
+ (oref lentic-config
:last-change-stop-converted)))
(error
- (linked-buffer-hook-fail err "before change")))))
+ (lentic-hook-fail err "before change")))))
-(defun linked-buffer-update-contents (conf &optional start stop length-before)
+(defun lentic-update-contents (conf &optional start stop length-before)
"Update the contents of that-buffer with the contents of this-buffer.
Update mechanism depends on CONF."
(unwind-protect
@@ -615,35 +616,35 @@ Update mechanism depends on CONF."
(oset conf :last-change-start-converted nil)
(oset conf :last-change-stop-converted nil)
(setq inhibit-read-only t)
- ;;(linked-buffer-log
- ;;"Update config: %s" linked-buffer-config)
- (linked-buffer-clone conf start stop length-before
+ ;;(lentic-log
+ ;;"Update config: %s" lentic-config)
+ (lentic-clone conf start stop length-before
start-converted stop-converted)
(setq inhibit-read-only nil))))
-(defun linked-buffer-update-point (conf)
+(defun lentic-update-point (conf)
"Update the location of point in that-buffer to reflect this-buffer.
This also attempts to update any windows so that they show the
same top-left location. Update details depend on CONF."
;; only sync when we are told to!
(when (oref conf :sync-point)
(let* ((from-point
- (linked-buffer-convert
+ (lentic-convert
conf
(with-current-buffer
- (linked-buffer-this conf)
+ (lentic-this conf)
(point))))
(from-window-start
- (linked-buffer-convert
+ (lentic-convert
conf
(window-start
(get-buffer-window
- (linked-buffer-this conf))))))
+ (lentic-this conf))))))
;; clone point in buffer important when the buffer is NOT visible in a
;; window at all
- ;;(linked-buffer-log "sync(front-point)(%s)" from-point)
+ ;;(lentic-log "sync(front-point)(%s)" from-point)
(with-current-buffer
- (linked-buffer-that conf)
+ (lentic-that conf)
(goto-char from-point))
;; now clone point in all the windows that are showing the buffer
;; and set the start of the window which is a reasonable attempt to show
@@ -654,7 +655,7 @@ same top-left location. Update details depend on CONF."
(progn
(goto-char from-point)
(set-window-start window from-window-start))))
- (get-buffer-window-list (linked-buffer-that conf))))))
+ (get-buffer-window-list (lentic-that conf))))))
;; #+end_src
@@ -662,41 +663,41 @@ same top-left location. Update details depend on CONF."
;; ** Minor Mode
;; #+begin_src emacs-lisp
-(defun linked-buffer-toggle-auto-sync-point ()
+(defun lentic-toggle-auto-sync-point ()
(interactive)
- (linked-buffer-when-linked
- (oset linked-buffer-config :sync-point
- (not (oref linked-buffer-config :sync-point)))))
+ (lentic-when-linked
+ (oset lentic-config :sync-point
+ (not (oref lentic-config :sync-point)))))
-(defvar linked-buffer-mode-map (make-sparse-keymap)
- "Keymap for linked-buffer-minor-mode")
+(defvar lentic-mode-map (make-sparse-keymap)
+ "Keymap for lentic-minor-mode")
-(define-key linked-buffer-mode-map
- (kbd "C-c ,s") 'linked-buffer-swap-linked-window)
+(define-key lentic-mode-map
+ (kbd "C-c ,s") 'lentic-swap-linked-window)
-(define-key linked-buffer-mode-map
- (kbd "C-c ,h") 'linked-buffer-move-linked-window)
+(define-key lentic-mode-map
+ (kbd "C-c ,h") 'lentic-move-linked-window)
-(define-minor-mode linked-buffer-mode
+(define-minor-mode lentic-mode
:lighter "lb"
- :keymap linked-buffer-mode-map)
+ :keymap lentic-mode-map)
(easy-menu-change
'("Edit")
- "Linked"
- '(["Create Here" linked-buffer-create-in-selected-window]
- ["Split Below" linked-buffer-split-window-below]
- ["Split Right" linked-buffer-split-window-right]
- ["Move Here" linked-buffer-move-linked-window :active linked-buffer-config]
- ["Swap" linked-buffer-swap-buffer-windows :active linked-buffer-config]))
-
-(defun linked-buffer-insert-file-local (init-function)
+ "Lentic"
+ '(["Create Here" lentic-create-in-selected-window]
+ ["Split Below" lentic-split-window-below]
+ ["Split Right" lentic-split-window-right]
+ ["Move Here" lentic-move-linked-window :active lentic-config]
+ ["Swap" lentic-swap-buffer-windows :active lentic-config]))
+
+(defun lentic-insert-file-local (init-function)
(interactive
(list (completing-read
- "Linked-Buffer init function: "
+ "Lentic init function: "
(mapcar
'symbol-name
- linked-buffer-init-functions)
+ lentic-init-functions)
'identity 'confirm)))
(save-excursion
(goto-char (point-max))
@@ -706,71 +707,71 @@ same top-left location. Update details depend on CONF."
;; split this string or we get local variable not terminated properly
;; errors.
(concat "\nLocal"
- " Variables:\nlinked-buffer-init: %s\nEnd:\n") init-function))
+ " Variables:\nlentic-init: %s\nEnd:\n") init-function))
(comment-region start (point)))))
-(defvar linked-buffer-start-mode-map (make-sparse-keymap))
+(defvar lentic-start-mode-map (make-sparse-keymap))
-(define-key linked-buffer-start-mode-map
- (kbd "C-c ,b") 'linked-buffer-split-window-below)
+(define-key lentic-start-mode-map
+ (kbd "C-c ,b") 'lentic-split-window-below)
-(define-key linked-buffer-start-mode-map
- (kbd "C-c ,r") 'linked-buffer-split-window-right)
+(define-key lentic-start-mode-map
+ (kbd "C-c ,r") 'lentic-split-window-right)
-(define-key linked-buffer-start-mode-map
- (kbd "C-c ,f") 'linked-buffer-insert-file-local)
+(define-key lentic-start-mode-map
+ (kbd "C-c ,f") 'lentic-insert-file-local)
-(define-key linked-buffer-start-mode-map
- (kbd "C-c ,c") 'linked-buffer-create-in-selected-window)
+(define-key lentic-start-mode-map
+ (kbd "C-c ,c") 'lentic-create-in-selected-window)
-(define-minor-mode linked-buffer-start-mode
+(define-minor-mode lentic-start-mode
:lighter ""
- :keymap linked-buffer-start-mode-map)
+ :keymap lentic-start-mode-map)
-(define-globalized-minor-mode global-linked-buffer-start-mode
- linked-buffer-start-mode
- linked-buffer-start-on)
+(define-globalized-minor-mode global-lentic-start-mode
+ lentic-start-mode
+ lentic-start-on)
-(defun linked-buffer-start-on ()
- (linked-buffer-start-mode 1))
+(defun lentic-start-on ()
+ (lentic-start-mode 1))
;; #+end_src
;; ** Test Functions
-;; Functions which are used for testing new linked-buffer-configurations; as
such
+;; Functions which are used for testing new lentic-configurations; as such
;; they are either batch operation functionality, or interactive commands to
run
;; the various hook commands rather than from the post-command or after-change
;; hook functionality.
;; #+begin_src emacs-lisp
-(defun linked-buffer-batch-clone-and-save-with-config (filename init)
+(defun lentic-batch-clone-and-save-with-config (filename init)
"Open FILENAME, set INIT function, then clone and save.
This function does potentially evil things if the file or the
-linked-buffer is open already."
+lentic is open already."
(with-current-buffer
(find-file-noselect filename)
- (setq linked-buffer-init init)
+ (setq lentic-init init)
(with-current-buffer
- (linked-buffer-init-create)
+ (lentic-init-create)
(save-buffer)
(kill-buffer))
(kill-buffer)))
-(defun linked-buffer-batch-clone-with-config
+(defun lentic-batch-clone-with-config
(filename init)
"Open FILENAME, set INIT function, then clone.
-Return the linked-buffer contents without properties."
+Return the lentic contents without properties."
(let ((retn nil))
(with-current-buffer
(find-file-noselect filename)
- (setq linked-buffer-init init)
+ (setq lentic-init init)
(with-current-buffer
- (linked-buffer-init-create)
+ (lentic-init-create)
(setq retn
(buffer-substring-no-properties
(point-min)
@@ -781,36 +782,36 @@ Return the linked-buffer contents without properties."
(kill-buffer))
retn))
-(defun linked-buffer-test-after-change-function ()
+(defun lentic-test-after-change-function ()
"Run the change functions out of the command loop.
Using this function is the easiest way to test an new
-`linked-buffer-clone' method, as doing so in the command loop is
-painful for debugging. Set variable `linked-buffer-emergency' to
+`lentic-clone' method, as doing so in the command loop is
+painful for debugging. Set variable `lentic-emergency' to
true to disable command loop functionality."
(interactive)
(message "Running after change with args: %s"
- linked-buffer-emergency-last-change)
- (apply 'linked-buffer-after-change-function-1
- linked-buffer-emergency-last-change))
+ lentic-emergency-last-change)
+ (apply 'lentic-after-change-function-1
+ lentic-emergency-last-change))
-(defun linked-buffer-test-post-command-hook ()
+(defun lentic-test-post-command-hook ()
"Run the post-command functions out of the command loop.
Using this function is the easiest way to test an new
-`linked-buffer-convert' method, as doing so in the command loop is
-painful for debugging. Set variable `linked-buffer-emergency' to
+`lentic-convert' method, as doing so in the command loop is
+painful for debugging. Set variable `lentic-emergency' to
true to disable command loop functionality."
(interactive)
- (linked-buffer-post-command-hook-1))
+ (lentic-post-command-hook-1))
-(defun linked-buffer-test-reinit ()
+(defun lentic-test-reinit ()
"Recall the init function regardless of current status.
This can help if you have change the config object and need
to make sure there is a new one."
(interactive)
- (funcall linked-buffer-init))
+ (funcall lentic-init))
-(provide 'linked-buffer)
+(provide 'lentic)
;; #+END_SRC
-;;; linked-buffer.el ends here
+;;; lentic.el ends here
diff --git a/test/lentic-test.el b/test/lentic-test.el
index 0a61abd27f..d40f1e6312 100644
--- a/test/lentic-test.el
+++ b/test/lentic-test.el
@@ -1,24 +1,24 @@
-(require 'linked-buffer)
-(require 'linked-buffer-latex-code)
-(require 'linked-buffer-asciidoc)
-(require 'linked-buffer-org)
+(require 'lentic)
+(require 'lentic-latex-code)
+(require 'lentic-asciidoc)
+(require 'lentic-org)
(require 'f)
-(defvar linked-buffer-test-dir
+(defvar lentic-test-dir
(concat
(file-name-directory
- (find-lisp-object-file-name 'linked-buffer-init 'defvar))
+ (find-lisp-object-file-name 'lentic-init 'defvar))
"dev-resources/"))
-(defun linked-buffer-test-file (filename)
+(defun lentic-test-file (filename)
(let ((file
- (concat linked-buffer-test-dir filename)))
+ (concat lentic-test-dir filename)))
(when (not (file-exists-p file))
(error "Test File does not exist: %s" file))
file))
-(defun linked-buffer-test-equal-loudly (a b)
+(defun lentic-test-equal-loudly (a b)
"Actually, this just tests equality and shouts if not."
;; change this to t to disable noisy printout
(if nil
@@ -57,85 +57,85 @@
(buffer-string))))
nil)))
-(defun linked-buffer-test-clone-equal (init file cloned-file)
+(defun lentic-test-clone-equal (init file cloned-file)
(let ((cloned-file
(f-read
- (linked-buffer-test-file cloned-file)))
+ (lentic-test-file cloned-file)))
(cloned-results
- (linked-buffer-batch-clone-with-config
- (linked-buffer-test-file file) init)))
- (linked-buffer-test-equal-loudly cloned-file cloned-results)))
+ (lentic-batch-clone-with-config
+ (lentic-test-file file) init)))
+ (lentic-test-equal-loudly cloned-file cloned-results)))
-(defun linked-buffer-test-clone-equal-generate
+(defun lentic-test-clone-equal-generate
(init file cloned-file)
- "Generates the test file for `linked-buffer-batch-clone-equal'."
+ "Generates the test file for `lentic-batch-clone-equal'."
(f-write
- (linked-buffer-batch-clone-with-config
- (linked-buffer-test-file file) init)
+ (lentic-batch-clone-with-config
+ (lentic-test-file file) init)
'utf-8
- (concat linked-buffer-test-dir cloned-file))
+ (concat lentic-test-dir cloned-file))
;; return nil, so if we use this in a test by mistake, it will crash out.
nil)
(defvar conf-default
- (linked-buffer-default-configuration "bob"))
+ (lentic-default-configuration "bob"))
-(ert-deftest linked-buffer-conf ()
+(ert-deftest lentic-conf ()
(should
(equal 'normal-mode
(oref conf-default :linked-mode))))
-(ert-deftest linked-buffer-simple ()
+(ert-deftest lentic-simple ()
(should
(equal "simple\n"
- (linked-buffer-batch-clone-with-config
- (linked-buffer-test-file "simple-contents.txt")
- 'linked-buffer-default-init))))
+ (lentic-batch-clone-with-config
+ (lentic-test-file "simple-contents.txt")
+ 'lentic-default-init))))
-(ert-deftest linked-buffer-clojure-latex ()
+(ert-deftest lentic-clojure-latex ()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-clojure-latex-init
+ (lentic-test-clone-equal
+ 'lentic-clojure-latex-init
"block-comment.clj" "block-comment-out.tex")))
-(ert-deftest linked-buffer-asciidoc-clojure ()
+(ert-deftest lentic-asciidoc-clojure ()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-asciidoc-clojure-init
+ (lentic-test-clone-equal
+ 'lentic-asciidoc-clojure-init
"asciidoc-clj.txt" "asciidoc-clj-out.clj")))
;; org mode start up prints out "OVERVIEW" from the cycle. Can't see any way
;; to stop this
-(ert-deftest linked-buffer-org-el ()
+(ert-deftest lentic-org-el ()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-org-el-init
+ (lentic-test-clone-equal
+ 'lentic-org-el-init
"org-el.org" "org-el.el")))
-(ert-deftest linked-buffer-el-org ()
+(ert-deftest lentic-el-org ()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-el-org-init
+ (lentic-test-clone-equal
+ 'lentic-el-org-init
"el-org.el" "el-org.org")))
-(ert-deftest linked-buffer-orgel-org()
+(ert-deftest lentic-orgel-org()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-orgel-org-init
+ (lentic-test-clone-equal
+ 'lentic-orgel-org-init
"orgel-org.el" "orgel-org.org")))
-(ert-deftest linked-buffer-org-orgel()
+(ert-deftest lentic-org-orgel()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-org-orgel-init
+ (lentic-test-clone-equal
+ 'lentic-org-orgel-init
"org-orgel.org" "org-orgel.el")))
-(ert-deftest linked-buffer-org-clojure ()
+(ert-deftest lentic-org-clojure ()
(should
- (linked-buffer-test-clone-equal
- 'linked-buffer-org-clojure-init
+ (lentic-test-clone-equal
+ 'lentic-org-clojure-init
"org-clojure.org" "org-clojure.clj"
)))
@@ -144,7 +144,7 @@
;; these test that buffers which are created and then changed are correct.
;; At the moment, this does not check that the changes are actually
;; incremental, cause that's harder.
-(defun linked-buffer-test-clone-and-change-with-config
+(defun lentic-test-clone-and-change-with-config
(filename init &optional f-this f-that retn-that)
"Clone file and make changes to check incremental updates.
Using INIT clone FILE, then apply F in the buffer, and return the
@@ -162,10 +162,10 @@ results."
(with-current-buffer
(setq this
(find-file-noselect filename))
- (setq linked-buffer-init init)
+ (setq lentic-init init)
(progn
(setq that
- (linked-buffer-init-create))
+ (lentic-init-create))
(funcall f-this)
(with-current-buffer
that
@@ -189,106 +189,106 @@ results."
(when that (kill-buffer that))))
))
-(defun linked-buffer-test-clone-and-change-equal
+(defun lentic-test-clone-and-change-equal
(init file cloned-file
&optional f-this f-that retn-that)
(let ((cloned-file
(f-read
- (linked-buffer-test-file cloned-file)))
+ (lentic-test-file cloned-file)))
(cloned-results
- (linked-buffer-test-clone-and-change-with-config
- (linked-buffer-test-file file) init f-this f-that
+ (lentic-test-clone-and-change-with-config
+ (lentic-test-file file) init f-this f-that
retn-that)))
(if
(string= cloned-file cloned-results)
t
;; comment this out if you don't want it.
- (linked-buffer-test-equal-loudly cloned-file cloned-results)
+ (lentic-test-equal-loudly cloned-file cloned-results)
nil)))
-(defun linked-buffer-test-clone-and-change-equal-generate
+(defun lentic-test-clone-and-change-equal-generate
(init file cloned-file f)
- "Generates the test file for
`linked-buffer-test-clone-and-change-with-config'."
+ "Generates the test file for `lentic-test-clone-and-change-with-config'."
(f-write
- (linked-buffer-test-clone-and-change-with-config
- (linked-buffer-test-file file) init
+ (lentic-test-clone-and-change-with-config
+ (lentic-test-file file) init
f)
'utf-8
- (concat linked-buffer-test-dir cloned-file))
+ (concat lentic-test-dir cloned-file))
;; return nil, so that if we use this in a test by mistake, it returns
;; false, so there is a good chance it will fail the test.
nil)
-(defvar linked-buffer-test-last-transform "")
+(defvar lentic-test-last-transform "")
-(defadvice linked-buffer-insertion-string-transform
+(defadvice lentic-insertion-string-transform
(before store-transform
(string)
activate)
- (setq linked-buffer-test-last-transform string))
+ (setq lentic-test-last-transform string))
-(ert-deftest linked-buffer-simple-with-change ()
+(ert-deftest lentic-simple-with-change ()
"Test simple-contents with a change, mostly to check my test machinary."
(should
(and
(equal "simple\nnot simple"
- (linked-buffer-test-clone-and-change-with-config
- (linked-buffer-test-file "simple-contents.txt")
- 'linked-buffer-default-init
+ (lentic-test-clone-and-change-with-config
+ (lentic-test-file "simple-contents.txt")
+ 'lentic-default-init
(lambda ()
(goto-char (point-max))
(insert "not simple"))))
- (equal linked-buffer-test-last-transform "not simple"))))
+ (equal lentic-test-last-transform "not simple"))))
-(ert-deftest linked-buffer-simple-with-change-file()
+(ert-deftest lentic-simple-with-change-file()
"Test simple-contents with a change and compare to file.
This mostly checks my test machinary."
(should
(and
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-default-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-default-init
"simple-contents.txt" "simple-contents-chg.txt"
(lambda ()
(goto-char (point-max))
(insert "simple")))
- (equal linked-buffer-test-last-transform "simple"))))
+ (equal lentic-test-last-transform "simple"))))
-(ert-deftest linked-buffer-clojure-latex-incremental ()
+(ert-deftest lentic-clojure-latex-incremental ()
(should
(and
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-clojure-latex-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-clojure-latex-init
"block-comment.clj" "block-comment-changed-out.tex"
(lambda ()
(forward-line 1)
(insert ";; inserted\n")))
- (equal linked-buffer-test-last-transform ";; inserted\n")))
+ (equal lentic-test-last-transform ";; inserted\n")))
(should
(and
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-latex-clojure-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-latex-clojure-init
"block-comment.tex" "block-comment-changed-1.clj"
(lambda ()
(forward-line 1)
(insert ";; inserted\n")))
- (equal linked-buffer-test-last-transform ";; inserted\n")))
+ (equal lentic-test-last-transform ";; inserted\n")))
(should
(and
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-latex-clojure-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-latex-clojure-init
"block-comment.tex" "block-comment-changed-2.clj"
(lambda ()
(search-forward "\\begin{code}\n")
(insert "(form inserted)\n")))
- (equal linked-buffer-test-last-transform "(form inserted)\n"))))
+ (equal lentic-test-last-transform "(form inserted)\n"))))
(ert-deftest clojure-latex-first-line ()
"Tests for a bug after introduction of incremental blocks."
(should
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-clojure-latex-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-clojure-latex-init
"block-comment.clj" "block-comment.tex"
(lambda ()
(delete-char 1)
@@ -299,8 +299,8 @@ This mostly checks my test machinary."
(ert-deftest clojure-latex-empty-line ()
"Tests for a deletion of an empty line"
(should
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-clojure-latex-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-clojure-latex-init
"block-comment.clj" "block-comment.tex"
nil
(lambda ()
@@ -311,8 +311,8 @@ This mostly checks my test machinary."
(ert-deftest orgel-org-incremental ()
(should
- (linked-buffer-test-clone-and-change-equal
- 'linked-buffer-orgel-org-init
+ (lentic-test-clone-and-change-equal
+ 'lentic-orgel-org-init
"orgel-org.el" "orgel-org.el"
nil
(lambda ()
- [elpa] externals/lentic d9ce04d541 087/333: Dependency updates., (continued)
- [elpa] externals/lentic d9ce04d541 087/333: Dependency updates., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 48644ea72c 083/333: Tests uncommented, and expected failures added., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 236e942322 079/333: Move point to change location., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 55c389ec2a 096/333: Cosmetic Change, ELPA Syncer, 2024/02/27
- [elpa] externals/lentic e2fc6ce904 097/333: Re-enabled orgel-org tests., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 1dad92f20a 095/333: Switch to exact-subtract., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic e0840dbfe6 082/333: Stop location now calculated from before functions., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 6ed73a2ef5 088/333: Add string transform function., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 6c5fabb400 091/333: dev options added., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 03ed3f4da2 119/333: Force loading of m-buffer on opening., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 582d4d72b3 125/333: Search and Replace to lentic.,
ELPA Syncer <=
- [elpa] externals/lentic a00f92e432 133/333: Refactor out a variable., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic a88717f0c4 102/333: Louder output for comments., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic da6ab1268f 104/333: Change locations now use markers., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 2dd5fcd6b3 105/333: Added let like macro to auto nil markers., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic e1941d0773 106/333: Easy mechanism to disable noisy fails., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 34d05cb7f9 108/333: Now uses random face., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic cebd7a744d 111/333: Add face as well as font-lock-face, ELPA Syncer, 2024/02/27
- [elpa] externals/lentic bb986c0676 116/333: New test for empty line bug., ELPA Syncer, 2024/02/27
- [elpa] externals/lentic 772186d38f 122/333: Merge branch 'feature/incremental-blocks-update', ELPA Syncer, 2024/02/27
- [elpa] externals/lentic fce88ba411 123/333: Added marmalade for noflet., ELPA Syncer, 2024/02/27