[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] 02/02: electric-spacing.el: Refactor by following electric.el min
|
From: |
William Xu |
|
Subject: |
[elpa] 02/02: electric-spacing.el: Refactor by following electric.el minor modes. |
|
Date: |
Sun, 13 Jul 2014 09:23:36 +0000 |
xwl pushed a commit to branch master
in repository elpa.
commit 7610e2434c0b123858070f5cfea89d8134017f54
Author: William Xu <address@hidden>
Date: Sun Jul 13 17:21:38 2014 +0800
electric-spacing.el: Refactor by following electric.el minor modes.
---
packages/electric-spacing/electric-spacing.el | 321 ++++++++++++-------------
1 files changed, 159 insertions(+), 162 deletions(-)
diff --git a/packages/electric-spacing/electric-spacing.el
b/packages/electric-spacing/electric-spacing.el
index 68332dd..fba04b6 100644
--- a/packages/electric-spacing/electric-spacing.el
+++ b/packages/electric-spacing/electric-spacing.el
@@ -1,10 +1,9 @@
-;;; smart-operator.el --- Insert operators with surrounding spaces smartly
+;;; electric-spacing.el --- Insert operators with surrounding spaces smartly
-;; Copyright (C) 2004, 2005, 2007-2013 Free Software Foundation, Inc.
+;; Copyright (C) 2004, 2005, 2007-2014 Free Software Foundation, Inc.
;; Author: William Xu <address@hidden>
;; Version: 4.0
-;; Url: http://xwl.appspot.com/ref/smart-operator.el
;; 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
@@ -40,66 +39,75 @@
(require 'cc-mode)
-;;; smart-operator minor mode
-
-(defvar smart-operator-mode-map
- (let ((keymap (make-sparse-keymap)))
- (define-key keymap "=" 'smart-operator-self-insert-command)
- (define-key keymap "<" 'smart-operator-<)
- (define-key keymap ">" 'smart-operator->)
- (define-key keymap "%" 'smart-operator-%)
- (define-key keymap "+" 'smart-operator-+)
- (define-key keymap "-" 'smart-operator--)
- (define-key keymap "*" 'smart-operator-*)
- (define-key keymap "/" 'smart-operator-/)
- (define-key keymap "&" 'smart-operator-&)
- (define-key keymap "|" 'smart-operator-self-insert-command)
- ;; (define-key keymap "!" 'smart-operator-self-insert-command)
- (define-key keymap ":" 'smart-operator-:)
- (define-key keymap "?" 'smart-operator-?)
- (define-key keymap "," 'smart-operator-\,)
- (define-key keymap "~" 'smart-operator-~)
- (define-key keymap "." 'smart-operator-.)
- keymap)
- "Keymap used my `smart-operator-mode'.")
-
-(defvar smart-operator-double-space-docs t
- "Enable double spacing of . in document lines - e,g, type '.' => get '. '")
-
-(defvar smart-operator-docs t
- "Enable smart-operator in strings and comments")
+;;; electric-spacing minor mode
+
+(defcustom electric-spacing-double-space-docs t
+ "Enable double spacing of . in document lines - e,g, type '.' => get '. '."
+ :type 'boolean
+ :group 'electricity)
+
+(defcustom electric-spacing-docs t
+ "Enable electric-spacing in strings and comments."
+ :type 'boolean
+ :group 'electricity)
+
+(defvar electric-spacing-rules
+ '((?= . electric-spacing-self-insert-command)
+ (?< . electric-spacing-<)
+ (?> . electric-spacing->)
+ (?% . electric-spacing-%)
+ (?+ . electric-spacing-+)
+ (?- . electric-spacing--)
+ (?* . electric-spacing-*)
+ (?/ . electric-spacing-/)
+ (?& . electric-spacing-&)
+ (?| . electric-spacing-self-insert-command)
+ (?: . electric-spacing-:)
+ (?? . electric-spacing-?)
+ (?, . electric-spacing-\,)
+ (?~ . electric-spacing-~)
+ (?. . electric-spacing-.)))
+
+(defun electric-spacing-post-self-insert-function ()
+ (when electric-spacing-mode
+ (let ((rule (cdr (assq last-command-event electric-spacing-rules))))
+ (when rule
+ (goto-char (electric--after-char-pos))
+ (delete-char -1)
+ (funcall rule)))))
+
+(add-hook 'post-self-insert-hook #'electric-spacing-post-self-insert-function)
;;;###autoload
-(define-minor-mode smart-operator-mode
- "Insert operators with surrounding spaces smartly."
- nil " _+_" smart-operator-mode-map)
-
-;;;###autoload
-(defun smart-operator-mode-on ()
- "Turn on `smart-operator-mode'. "
- (smart-operator-mode 1))
-
-;;;###autoload
-(defun smart-operator-self-insert-command (arg)
- "Insert the entered operator plus surrounding spaces."
- (interactive "p")
- (smart-operator-insert (string last-command-event)))
-
-(defvar smart-operator-list
- '("=" "<" ">" "%" "+" "-" "*" "/" "&" "|" "!" ":" "?" "," "."))
-
-(defun smart-operator-insert (op &optional only-where)
- "See `smart-operator-insert-1'."
+(define-minor-mode electric-spacing-mode
+ "Toggle automatic surrounding space insertion (Electric Spacing mode).
+With a prefix argument ARG, enable Electric Spacing mode if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil.
+
+This is a local minor mode. When enabled, typing an operator automatically
+inserts surrounding spaces. e.g., `=' becomes ` = ',`+=' becomes ` += '. This
+is very handy for many programming languages."
+ :global nil
+ :group 'electricity
+ :lighter " _+_")
+
+(defun electric-spacing-self-insert-command ()
+ "Insert character with surrounding spaces."
+ (electric-spacing-insert (string last-command-event)))
+
+(defun electric-spacing-insert (op &optional only-where)
+ "See `electric-spacing-insert-1'."
(delete-horizontal-space)
- (cond ((and (smart-operator-lispy-mode?)
- (not (smart-operator-document-line?)))
- (smart-operator-lispy op))
- ((not smart-operator-docs)
- (smart-operator-insert-1 op 'middle))
+ (cond ((and (electric-spacing-lispy-mode?)
+ (not (electric-spacing-document?)))
+ (electric-spacing-lispy op))
+ ((not electric-spacing-docs)
+ (electric-spacing-insert-1 op 'middle))
(t
- (smart-operator-insert-1 op only-where))))
+ (electric-spacing-insert-1 op only-where))))
-(defun smart-operator-insert-1 (op &optional only-where)
+(defun electric-spacing-insert-1 (op &optional only-where)
"Insert operator OP with surrounding spaces.
e.g., `=' becomes ` = ', `+=' becomes ` += '.
@@ -112,7 +120,9 @@ when `only-where' is 'middle, we will not insert space."
(`after (insert op " "))
(_
(let ((begin? (bolp)))
- (unless (or (looking-back (regexp-opt smart-operator-list)
+ (unless (or (looking-back (regexp-opt
+ (mapcar 'char-to-string
+ (mapcar 'car
electric-spacing-rules)))
(line-beginning-position))
begin?)
(insert " "))
@@ -120,19 +130,19 @@ when `only-where' is 'middle, we will not insert space."
(when begin?
(indent-according-to-mode))))))
-(defun smart-operator-c-types ()
+(defun electric-spacing-c-types ()
(concat c-primitive-type-key "?"))
-(defun smart-operator-document-line? ()
- (memq (syntax-ppss-context (syntax-ppss)) '(comment string)))
+(defun electric-spacing-document? ()
+ (nth 8 (syntax-ppss)))
-(defun smart-operator-lispy-mode? ()
- (memq major-mode '(emacs-lisp-mode
- lisp-mode
- lisp-interaction-mode
- scheme-mode)))
+(defun electric-spacing-lispy-mode? ()
+ (derived-mode-p 'emacs-lisp-mode
+ 'lisp-mode
+ 'lisp-interaction-mode
+ 'scheme-mode))
-(defun smart-operator-lispy (op)
+(defun electric-spacing-lispy (op)
"We're in a Lisp-ish mode, so let's look for parenthesis.
Meanwhile, if not found after ( operators are more likely to be function names,
so let's not get too insert-happy."
@@ -141,84 +151,79 @@ so let's not get too insert-happy."
(backward-char 1)
(looking-at "("))
(if (equal op ",")
- (smart-operator-insert-1 op 'middle)
- (smart-operator-insert-1 op 'after)))
+ (electric-spacing-insert-1 op 'middle)
+ (electric-spacing-insert-1 op 'after)))
((equal op ",")
- (smart-operator-insert-1 op 'before))
+ (electric-spacing-insert-1 op 'before))
(t
- (smart-operator-insert-1 op 'middle))))
+ (electric-spacing-insert-1 op 'middle))))
;;; Fine Tunings
-(defun smart-operator-< ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-< ()
+ "See `electric-spacing-insert'."
(cond
((or (and c-buffer-is-cc-mode
(looking-back
(concat "\\("
(regexp-opt
'("#include" "vector" "deque" "list" "map" "stack"
- "multimap" "set" "hash_map" "iterator" "template"
- "pair" "auto_ptr" "static_cast"
- "dynmaic_cast" "const_cast" "reintepret_cast"
+ "multimap" "set" "hash_map" "iterator" "template"
+ "pair" "auto_ptr" "static_cast"
+ "dynmaic_cast" "const_cast" "reintepret_cast"
- "#import"))
+ "#import"))
"\\)\\ *")
(line-beginning-position)))
- (eq major-mode 'sgml-mode))
+ (derived-mode-p 'sgml-mode))
(insert "<>")
(backward-char))
(t
- (smart-operator-insert "<"))))
+ (electric-spacing-insert "<"))))
-(defun smart-operator-: ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-: ()
+ "See `electric-spacing-insert'."
(cond (c-buffer-is-cc-mode
(if (looking-back "\\?.+")
- (smart-operator-insert ":")
- (smart-operator-insert ":" 'middle)))
- ((memq major-mode '(haskell-mode))
- (smart-operator-insert ":"))
+ (electric-spacing-insert ":")
+ (electric-spacing-insert ":" 'middle)))
+ ((derived-mode-p 'haskell-mode)
+ (electric-spacing-insert ":"))
(t
- (smart-operator-insert ":" 'after))))
-
-(defun smart-operator-\, ()
- "See `smart-operator-insert'."
- (interactive)
- (smart-operator-insert "," 'after))
-
-(defun smart-operator-. ()
- "See `smart-operator-insert'."
- (interactive)
- (cond ((and smart-operator-double-space-docs
- (smart-operator-document-line?))
- (smart-operator-insert "." 'after)
+ (electric-spacing-insert ":" 'after))))
+
+(defun electric-spacing-\, ()
+ "See `electric-spacing-insert'."
+ (electric-spacing-insert "," 'after))
+
+(defun electric-spacing-. ()
+ "See `electric-spacing-insert'."
+ (cond ((and electric-spacing-double-space-docs
+ (electric-spacing-document?))
+ (electric-spacing-insert "." 'after)
(insert " "))
((or (looking-back "[0-9]")
(or (and c-buffer-is-cc-mode
(looking-back "[a-z]"))
(and
- (memq major-mode '(python-mode ruby-mode))
+ (derived-mode-p 'python-mode 'ruby-mode)
(looking-back "[a-z\)]"))
(and
- (memq major-mode '(js-mode js2-mode))
+ (derived-mode-p 'js-mode 'js2-mode)
(looking-back "[a-z\)$]"))))
- (insert "."))
- ((memq major-mode '(cperl-mode perl-mode ruby-mode))
+ (insert "."))
+ ((derived-mode-p 'cperl-mode 'perl-mode 'ruby-mode)
;; Check for the .. range operator
(if (looking-back ".")
- (insert ".")
+ (insert ".")
(insert " . ")))
(t
- (smart-operator-insert "." 'after)
+ (electric-spacing-insert "." 'after)
(insert " "))))
-(defun smart-operator-& ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-& ()
+ "See `electric-spacing-insert'."
(cond (c-buffer-is-cc-mode
;; ,----[ cases ]
;; | char &a = b; // FIXME
@@ -227,18 +232,17 @@ so let's not get too insert-happy."
;; | int c = a & b;
;; | a && b;
;; `----
- (cond ((looking-back (concat (smart-operator-c-types) " *" ))
- (smart-operator-insert "&" 'after))
+ (cond ((looking-back (concat (electric-spacing-c-types) " *" ))
+ (electric-spacing-insert "&" 'after))
((looking-back "= *")
- (smart-operator-insert "&" 'before))
+ (electric-spacing-insert "&" 'before))
(t
- (smart-operator-insert "&"))))
+ (electric-spacing-insert "&"))))
(t
- (smart-operator-insert "&"))))
+ (electric-spacing-insert "&"))))
-(defun smart-operator-* ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-* ()
+ "See `electric-spacing-insert'."
(cond (c-buffer-is-cc-mode
;; ,----
;; | a * b;
@@ -248,66 +252,61 @@ so let's not get too insert-happy."
;; | *p++;
;; | *a = *b;
;; `----
- (cond ((looking-back (concat (smart-operator-c-types) " *" ))
- (smart-operator-insert "*" 'before))
+ (cond ((looking-back (concat (electric-spacing-c-types) " *" ))
+ (electric-spacing-insert "*" 'before))
((looking-back "\\* *")
- (smart-operator-insert "*" 'middle))
+ (electric-spacing-insert "*" 'middle))
((looking-back "^[ (]*")
- (smart-operator-insert "*" 'middle)
+ (electric-spacing-insert "*" 'middle)
(indent-according-to-mode))
((looking-back "= *")
- (smart-operator-insert "*" 'before))
+ (electric-spacing-insert "*" 'before))
(t
- (smart-operator-insert "*"))))
+ (electric-spacing-insert "*"))))
(t
- (smart-operator-insert "*"))))
+ (electric-spacing-insert "*"))))
-(defun smart-operator-> ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-> ()
+ "See `electric-spacing-insert'."
(cond ((and c-buffer-is-cc-mode (looking-back " - "))
(delete-char -3)
(insert "->"))
(t
- (smart-operator-insert ">"))))
+ (electric-spacing-insert ">"))))
-(defun smart-operator-+ ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-+ ()
+ "See `electric-spacing-insert'."
(cond ((and c-buffer-is-cc-mode (looking-back "\\+ *"))
(when (looking-back "[a-zA-Z0-9_] +\\+ *")
(save-excursion
(backward-char 2)
(delete-horizontal-space)))
- (smart-operator-insert "+" 'middle)
+ (electric-spacing-insert "+" 'middle)
(indent-according-to-mode))
(t
- (smart-operator-insert "+"))))
+ (electric-spacing-insert "+"))))
-(defun smart-operator-- ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-- ()
+ "See `electric-spacing-insert'."
(cond ((and c-buffer-is-cc-mode (looking-back "\\- *"))
(when (looking-back "[a-zA-Z0-9_] +\\- *")
(save-excursion
(backward-char 2)
(delete-horizontal-space)))
- (smart-operator-insert "-" 'middle)
+ (electric-spacing-insert "-" 'middle)
(indent-according-to-mode))
(t
- (smart-operator-insert "-"))))
+ (electric-spacing-insert "-"))))
-(defun smart-operator-? ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-? ()
+ "See `electric-spacing-insert'."
(cond (c-buffer-is-cc-mode
- (smart-operator-insert "?"))
+ (electric-spacing-insert "?"))
(t
- (smart-operator-insert "?" 'after))))
+ (electric-spacing-insert "?" 'after))))
-(defun smart-operator-% ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-% ()
+ "See `electric-spacing-insert'."
(cond (c-buffer-is-cc-mode
;; ,----
;; | a % b;
@@ -316,20 +315,19 @@ so let's not get too insert-happy."
(if (and (looking-back "\".*")
(not (looking-back "\",.*")))
(insert "%")
- (smart-operator-insert "%")))
+ (electric-spacing-insert "%")))
;; If this is a comment or string, we most likely
;; want no spaces - probably string formatting
- ((and (memq major-mode '(python-mode))
- (smart-operator-document-line?))
- (insert "%"))
+ ((and (derived-mode-p 'python-mode)
+ (electric-spacing-document?))
+ (insert "%"))
(t
- (smart-operator-insert "%"))))
+ (electric-spacing-insert "%"))))
-(defun smart-operator-~ ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-~ ()
+ "See `electric-spacing-insert'."
;; First class regex operator =~ langs
- (cond ((memq major-mode '(ruby-mode perl-mode cperl-mode))
+ (cond ((derived-mode-p 'ruby-mode 'perl-mode 'cperl-mode)
(if (looking-back "= ")
(progn
(delete-char -2)
@@ -338,9 +336,8 @@ so let's not get too insert-happy."
(t
(insert "~"))))
-(defun smart-operator-/ ()
- "See `smart-operator-insert'."
- (interactive)
+(defun electric-spacing-/ ()
+ "See `electric-spacing-insert'."
;; *nix shebangs #!
(cond ((and (eq 1 (line-number-at-pos))
(save-excursion
@@ -348,8 +345,8 @@ so let's not get too insert-happy."
(looking-at "#!")))
(insert "/"))
(t
- (smart-operator-insert "/"))))
+ (electric-spacing-insert "/"))))
-(provide 'smart-operator)
+(provide 'electric-spacing)
-;;; smart-operator.el ends here
+;;; electric-spacing.el ends here