[ELPA] New package: cycle-quotes.el

[ELPA] New package: cycle-quotes.el

[Simen Heggestøyl]

[-- Attachment #1: Type: text/plain, Size: 1179 bytes --]

Hello.

I'd like to offer a package I've written, cycle-quotes.el, for GNU ELPA.

It's a convenience package providing a command to cycle between
different string quoting styles. For instance, in JavaScript, there's
three string quote characters: ", ` and '. In a JavaScript buffer, with
point located someplace within the string, the `cycle-quotes' command
will cycle between these quote styles each time the command is called:

   --> "Hi, it's me!" --> `Hi, it's me!` --> 'Hi, it\'s me!' --
  |                                                            |
   ------------------------------------------------------------

As seen in the above example, it handles escaping and unescaping of
quote characters inside the string.

I've been using the package privately for some time now and found it
useful, so maybe others will find it useful too.

There is a similar package available from MELPA, toggle-quotes.el, but
it works differently. toggle-quotes.el toggles between the " and '
quotes, while cycle-quotes.el uses the current mode's syntax table to
determine which quote characters to cycle between (so it's able to
support an arbitrary number of quote styles).

-- Simen

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2.1: cycle-quotes-test.el --]
[-- Type: text/x-emacs-lisp, Size: 3004 bytes --]

;;; cycle-quotes-test.el --- Tests for cycle-quotes.el  -*- lexical-binding: t; -*-

;; Copyright (C) 2015-2016  Simen Heggestøyl

;; Author: Simen Heggestøyl <simenheg@gmail.com>

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

(require 'cycle-quotes)
(require 'ert)
;; For testing triple quotes
(require 'python)

(ert-deftest test-cycle-quotes--set-quote-chars ()
  (with-temp-buffer
    (let ((st (make-syntax-table)))
      (set-syntax-table st)
      (modify-syntax-entry ?a "\"")
      (modify-syntax-entry ?b "\"")
      (cycle-quotes--set-quote-chars)
      (should (= (length cycle-quotes--quote-chars) 3))
      (should (memq ?a cycle-quotes--quote-chars))
      (should (memq ?b cycle-quotes--quote-chars))
      (should (memq ?\" cycle-quotes--quote-chars)))))

(ert-deftest test-cycle-quotes--next-quote-char ()
  (let ((cycle-quotes--quote-chars '(?a)))
    (should (= (cycle-quotes--next-quote-char ?a) ?a)))
  (let ((cycle-quotes--quote-chars '(?a ?b)))
    (should (= (cycle-quotes--next-quote-char ?a) ?b)))
  (let ((cycle-quotes--quote-chars '(?a ?b ?c)))
    (should (= (cycle-quotes--next-quote-char ?c) ?a))))

(ert-deftest test-cycle-quotes--fix-escapes ()
  (with-temp-buffer
    (insert "b\\baabc\\b")
    (cycle-quotes--fix-escapes (point-min) (point-max) ?a ?b)
    (should (equal (buffer-string) "bb\\a\\abcb"))))

(ert-deftest test-cycle-quotes ()
  (with-temp-buffer
    (let ((st (make-syntax-table)))
      (set-syntax-table st)
      (modify-syntax-entry ?' "\"")
      (modify-syntax-entry ?` "\"")
      (insert "\"Hi, it's me!\"")
      (goto-char 5)
      (cycle-quotes)
      (should (equal (buffer-string) "`Hi, it's me!`"))
      (cycle-quotes)
      (should (equal (buffer-string) "'Hi, it\\'s me!'"))
      (cycle-quotes)
      (should (equal (buffer-string) "\"Hi, it's me!\"")))))

(ert-deftest test-cycle-quotes-triple-quotes ()
  (with-temp-buffer
    (python-mode)
    (insert "'''Triple quotes, as found in Python.'''")
    (goto-char 5)
    (cycle-quotes)
    (should (equal (buffer-string)
                   "\"\"\"Triple quotes, as found in Python.\"\"\""))
    (cycle-quotes)
    (should (equal (buffer-string)
                   "'''Triple quotes, as found in Python.'''"))))

(provide 'cycle-quotes-test)
;;; cycle-quotes-test.el ends here

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2.2: cycle-quotes.el --]
[-- Type: text/x-emacs-lisp, Size: 6143 bytes --]

;;; cycle-quotes.el --- Cycle between quote styles  -*- lexical-binding: t; -*-

;; Copyright (C) 2015-2016  Simen Heggestøyl

;; Author: Simen Heggestøyl <simenheg@gmail.com>
;; Keywords: convenience
;; Version: 0.1

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; This package provides the `cycle-quotes' function to cycle between
;; different string quote styles. For instance, in JavaScript, there's
;; three string quote characters: ", ` and '.  In a JavaScript buffer,
;; with point located someplace within the string, `cycle-quotes' will
;; cycle between the following quote styles each time it's called:
;;
;;    --> "Hi, it's me!" --> `Hi, it's me!` --> 'Hi, it\'s me!' --
;;   |                                                            |
;;    ------------------------------------------------------------
;;
;; As seen in the above example, `cycle-quotes' tries to escape and
;; unescape quote characters intelligently.

;;; Code:

(defvar-local cycle-quotes--quote-chars '()
  "A list of string quote characters for the current mode.
Set the first time `cycle-quotes' is called in a buffer.")

(defvar-local cycle-quotes--quote-chars-mode nil
  "The latest mode that the quote char list was last computed for.
If this is different from the current mode, the quote chars need
to be recomputed.")

(defun cycle-quotes--set-quote-chars ()
  "Set the quote chars for the current syntax table."
  (let ((syntax-table (syntax-table)))
    (while syntax-table
      (map-char-table
       (lambda (char-code-or-range syntax)
         (when (equal syntax (string-to-syntax "\""))
           (if (consp char-code-or-range)
               (let ((from (car char-code-or-range))
                     (to (cdr char-code-or-range)))
                 (dolist (char-code (number-sequence from to))
                   (add-to-list 'cycle-quotes--quote-chars char-code)))
             (add-to-list
              'cycle-quotes--quote-chars char-code-or-range))))
       syntax-table)
      (setq syntax-table (char-table-parent syntax-table)))
    (setq-local cycle-quotes--quote-chars-mode major-mode)))

(defun cycle-quotes--next-quote-char (char)
  "Return quote char after CHAR."
  (let ((list-from-char (member char cycle-quotes--quote-chars)))
    (when list-from-char
      (if (= (length list-from-char) 1)
          (car cycle-quotes--quote-chars)
        (cadr list-from-char)))))

(defun cycle-quotes--fix-escapes (beg end escape-char unescape-char)
  "Fix character escapes between BEG and END.
Instances of ESCAPE-CHAR will be escaped by `\', while instances
where UNESCAPE-CHAR are escaped by `\' will have their escape
character removed."
  (let ((escape-string (string escape-char))
        (unescape-string (string unescape-char)))
    (save-excursion
      (goto-char end)
      (while (search-backward (concat "\\" unescape-string) beg t)
        (replace-match unescape-string nil t)))
    (save-excursion
      (goto-char end)
      (while (search-backward escape-string beg t)
        (replace-match (concat "\\" escape-string) nil t)
        (forward-char -1)))))

;;;###autoload
(defun cycle-quotes ()
  "Cycle between string quote styles."
  (interactive)
  (unless (eq major-mode cycle-quotes--quote-chars-mode)
    (cycle-quotes--set-quote-chars))
  (if (< (length cycle-quotes--quote-chars) 2)
      (message "The current mode has no alternative quote syntax")
    (let ((quote-char (nth 3 (syntax-ppss))))
      (if (not quote-char)
          (message "Not inside a string")
        (let ((inside-generic-string (eq quote-char t))
              ;; Can't use `save-excursion', because the marker will get
              ;; deleted if point is at the beginning of the string.
              (start-pos (point)))
          (when inside-generic-string
            (skip-syntax-backward "^|")
            (forward-char -1)
            (setq quote-char (char-after)))
          (let ((new-quote-char
                 (cycle-quotes--next-quote-char
                  (if inside-generic-string
                      (char-after)
                    quote-char))))
            (unless inside-generic-string
              (search-backward-regexp
               (concat "\\([^\\]" (string quote-char) "\\)\\|"
                       "^" (string quote-char)))
              (when (match-beginning 1)
                (forward-char)))
            (let ((repeat
                   ;; Handle multiple quotes, such as Python's triple
                   ;; quotes.
                   (save-excursion
                     (search-forward-regexp
                      (format "%c+" quote-char))
                     (- (match-end 0) (match-beginning 0)))))
              (save-excursion
                (let ((beg (point)))
                  (forward-sexp)
                  ;; `forward-sexp' fails to jump to the matching quote
                  ;; in some modes, for instance `js2-mode'.
                  (skip-syntax-backward "^\"|")
                  (cycle-quotes--fix-escapes
                   (+ beg 1) (+ (point) 1) new-quote-char quote-char))
                (delete-char (- repeat))
                (dotimes (_ repeat)
                  (insert new-quote-char)))
              (delete-char repeat)
              (dotimes (_ repeat)
                (insert new-quote-char))))
          (goto-char start-pos))))))

(provide 'cycle-quotes)
;;; cycle-quotes.el ends here

Re: [ELPA] New package: cycle-quotes.el

[Kaushal Modi]

[-- Attachment #1: Type: text/plain, Size: 483 bytes --]

Sounds cool! Have you tested to see how it works in emacs-lisp-mode?

Also, if a region is active, and if that selection is not surrounded by
quotes, would cycle-quotes wrap that region with quotes? And cycle back to
no quotes while that same region was active?

On Sat, Jun 4, 2016, 7:00 AM Simen Heggestøyl <simenheg@gmail.com> wrote:

> Hello.
>
> I'd like to offer a package I've written, cycle-quotes.el, for GNU ELPA.
> quote styles).
>
-- 

-- 
Kaushal Modi

[-- Attachment #2: Type: text/html, Size: 865 bytes --]

Re: [ELPA] New package: cycle-quotes.el

[Simen Heggestøyl]

On Sat, Jun 4, 2016 at 1:51 PM, Kaushal Modi <kaushal.modi@gmail.com> 
wrote:
> Sounds cool! Have you tested to see how it works in emacs-lisp-mode?
> Also, if a region is active, and if that selection is not surrounded 
> by quotes, would cycle-quotes wrap that region with quotes? And cycle 
> back to no quotes while that same region was active?
> 

It currently doesn't care about the region. `cycle-quotes' will only
change the quoting style of the surrounding quotes when point is inside
a string (as defined by the syntax of the current major mode).

So for Emacs Lisp that has only one string quoting character (as far as
I know), `cycle-quotes' will do nothing. But for programming modes that
defines more than one string quote character, such as for Python or
JavaScript, `cycle-quotes' will cycle between the different styles.

-- Simen

Re: [ELPA] New package: cycle-quotes.el

[Stefan Monnier]

> I'd like to offer a package I've written, cycle-quotes.el, for GNU ELPA.

Sounds good.  Feel free to add it.


        Stefan


PS: it would be nice to add hook so that other string quotes can be
supported such as the """ of Python.

Re: [ELPA] New package: cycle-quotes.el

[Simen Heggestøyl]

On Sat, Jun 4, 2016 at 7:00 PM, Stefan Monnier 
<monnier@iro.umontreal.ca> wrote:
> Sounds good.  Feel free to add it.

Added, thanks.

> PS: it would be nice to add hook so that other string quotes can be
> supported such as the """ of Python.

It already supports Python's triple quotes by looking for multiple
successive quote characters.

-- Simen

Re: [ELPA] New package: cycle-quotes.el

[Michael Mauger]

on Sun, Jun 5th at 6:51a, Simen Heggestøyl-2 said:

> It already supports Python's triple quotes by looking for multiple
> successive quote characters.

There are other styles of strings that could be supported. In SQL, there are
several dialect-specific string styles. String terminators and escape
mechanisms are dependent on string introducers and dialect. I wouldn't
expect that you're package would support all of them, but possibly it could
rely upon local buffer variables and mode-specific hooks to provide parsing
and alternative support. 

As examples, 
SQLite: supports single quotes
Postgres: supports single quotes, $$..$$, and $xyz$ .. $xyz$ and other
syntaxes
Oracle (sorry they are the 800lb gorilla when it comes to SQL): supports
single quotes, Q'x .. x' (where x is ), ], }, or > in the terminator if the
first x is (, [, {, or < respectively, or the same character is used in the
start and end otherwise)

The functionality you provide is useful, but making it so that mode-specific
hooks can provide the intelligent details, while your module provides the
engine for cycling and escaping might be a future direction. 

Thanks for your contribution.

-- 
Michael Mauger: maintainer sql.el



--
View this message in context: http://emacs.1067599.n5.nabble.com/ELPA-New-package-cycle-quotes-el-tp399526p399665.html
Sent from the Emacs - Dev mailing list archive at Nabble.com.

Re: [ELPA] New package: cycle-quotes.el

[Simen Heggestøyl]

Michael Mauger <mmaug@yahoo.com> writes:
> There are other styles of strings that could be supported. In SQL, there are
> several dialect-specific string styles. String terminators and escape
> mechanisms are dependent on string introducers and dialect. I wouldn't
> expect that you're package would support all of them, but possibly it could
> rely upon local buffer variables and mode-specific hooks to provide parsing
> and alternative support. 
>
> As examples, 
> SQLite: supports single quotes
> Postgres: supports single quotes, $$..$$, and $xyz$ .. $xyz$ and other
> syntaxes
> Oracle (sorry they are the 800lb gorilla when it comes to SQL): supports
> single quotes, Q'x .. x' (where x is ), ], }, or > in the terminator if the
> first x is (, [, {, or < respectively, or the same character is used in the
> start and end otherwise)
>
> The functionality you provide is useful, but making it so that mode-specific
> hooks can provide the intelligent details, while your module provides the
> engine for cycling and escaping might be a future direction. 
>
> Thanks for your contribution.

Thanks for your feedback, Michael. I see now that it could be useful
to provide such hooks.

Is it OK for you if I send you some diffs for review while working on
this feature?

-- Simen

Re: [ELPA] New package: cycle-quotes.el

[Simen Heggestøyl]

[-- Attachment #1: Type: text/plain, Size: 350 bytes --]

Michael Mauger <mmaug@yahoo.com> writes:
> The functionality you provide is useful, but making it so that mode-specific
> hooks can provide the intelligent details, while your module provides the
> engine for cycling and escaping might be a future direction. 

Michael, Stefan, will something like this provide enough flexibility for
you?

-- Simen


[-- Attachment #2: cycle-quotes-hooks.diff --]
[-- Type: text/x-diff, Size: 4490 bytes --]

diff --git a/cycle-quotes.el b/cycle-quotes.el
index faac0cb..075ab98 100644
--- a/cycle-quotes.el
+++ b/cycle-quotes.el
@@ -45,9 +45,13 @@ Set the first time `cycle-quotes' is called in a buffer.")
 If this is different from the current mode, the quote chars need
 to be recomputed.")
 
-(defun cycle-quotes--set-quote-chars ()
-  "Set the quote chars for the current syntax table."
-  (let ((syntax-table (syntax-table)))
+(defun cycle-quotes-quote-chars ()
+  "Return a list of quote characters for the current mode.
+This is the default value of `cycle-quotes-quote-chars-function'.
+It uses the syntax table for the current mode to determine which
+characters should be regarded as quote characters."
+  (let ((syntax-table (syntax-table))
+        (quote-chars '()))
     (while syntax-table
       (map-char-table
        (lambda (char-code-or-range syntax)
@@ -56,12 +60,50 @@ to be recomputed.")
                (let ((from (car char-code-or-range))
                      (to (cdr char-code-or-range)))
                  (dolist (char-code (number-sequence from to))
-                   (add-to-list 'cycle-quotes--quote-chars char-code)))
-             (add-to-list
-              'cycle-quotes--quote-chars char-code-or-range))))
+                   (add-to-list 'quote-chars char-code)))
+             (add-to-list 'quote-chars char-code-or-range))))
        syntax-table)
       (setq syntax-table (char-table-parent syntax-table)))
-    (setq-local cycle-quotes--quote-chars-mode major-mode)))
+    quote-chars))
+
+(defun cycle-quotes-surrounding-quote ()
+  "Return the surrounding quote character if point is inside a string.
+This is the default value of
+`cycle-quotes-surrounding-quote-function'."
+  (nth 3 (syntax-ppss)))
+
+(defun cycle-quotes-forward-string ()
+  "Move point across the string directly after point.
+This is the default value of
+`cycle-quotes-forward-string-function'."
+  (forward-sexp)
+  ;; `forward-sexp' fails to jump to the matching quote in some modes,
+  ;; for instance `js2-mode'.
+  (skip-syntax-backward "^\"|"))
+
+(defvar-local cycle-quotes-quote-chars-function
+  #'cycle-quotes-quote-chars
+  "Function returning quote characters for the current mode.")
+
+(defvar-local cycle-quotes-surrounding-quote-function
+  #'cycle-quotes-surrounding-quote
+  "Function returning the quote character surrounding point.
+It should return the surrounding quote character if point is
+inside a string.  If not, it should return nil.")
+
+(defvar-local cycle-quotes-forward-string-function
+  #'cycle-quotes-forward-string
+  "Function moving point across a string directly after point.
+For instance, if this function is called when point is at `★':
+
+    ★'Let\'s go!'
+
+Point should end up at the end up after the last quote:
+
+     'Let\'s go!'★
+
+Just calling `forward-sexp' should work for most modes, where
+quote characters have been given string quote syntax.")
 
 (defun cycle-quotes--next-quote-char (char)
   "Return quote char after CHAR."
@@ -93,10 +135,13 @@ character removed."
   "Cycle between string quote styles."
   (interactive)
   (unless (eq major-mode cycle-quotes--quote-chars-mode)
-    (cycle-quotes--set-quote-chars))
+    (let ((quote-chars (funcall cycle-quotes-quote-chars-function)))
+      (setq-local cycle-quotes--quote-chars quote-chars))
+    (setq-local cycle-quotes--quote-chars-mode major-mode))
   (if (< (length cycle-quotes--quote-chars) 2)
       (message "The current mode has no alternative quote syntax")
-    (let ((quote-char (nth 3 (syntax-ppss))))
+    (let ((quote-char
+           (funcall cycle-quotes-surrounding-quote-function)))
       (if (not quote-char)
           (message "Not inside a string")
         (let ((inside-generic-string (eq quote-char t))
@@ -127,10 +172,7 @@ character removed."
                      (- (match-end 0) (match-beginning 0)))))
               (save-excursion
                 (let ((beg (point)))
-                  (forward-sexp)
-                  ;; `forward-sexp' fails to jump to the matching quote
-                  ;; in some modes, for instance `js2-mode'.
-                  (skip-syntax-backward "^\"|")
+                  (funcall cycle-quotes-forward-string-function)
                   (cycle-quotes--fix-escapes
                    (+ beg 1) (+ (point) 1) new-quote-char quote-char))
                 (delete-char (- repeat))

Re: [ELPA] New package: cycle-quotes.el

[Stefan Monnier]

> Michael, Stefan, will something like this provide enough flexibility for
> you?

I don't really have the time to try and think about what's needed to
cover the different possible needs.  But I don't see an urgent need to
come up with a perfect solution either.

So you might like to simply take it incrementally, adding support for
new cases as you bump into them.  Also, you have to weight the cost of
implementation/flexibility against the likelihood of it being used.
E.g. I'm not sure it'd be worth the trouble trying to add support for
switching between '...' quoting and heredoc-quoting in sh-mode.

Similarly, in sh-mode I could imagine situations where switching
correctly from "..." to '...' would require extra processing to make
sure any $... embedded in the string is still expanded.  But should we
really cater to such cases?


        Stefan