Remove dependency on names

Author: davidshepherd7

Cask

@@ -10,5 +10,4 @@
 
 (development
  (depends-on "ecukes")
- (depends-on "espuds")
- (depends-on "names"))
+ (depends-on "espuds"))

fill-function-arguments.el

@@ -4,7 +4,7 @@
 
 ;; Author: David Shepherd <[email protected]>
 ;; Version: 0.3
-;; Package-Requires: ((names "20150618.0") (emacs "24.5"))
+;; Package-Requires: ((emacs "24.5"))
 ;; Keywords:
 ;; URL: https://github.com/davidshepherd7/fill-function-arguments
 
@@ -13,28 +13,19 @@
 
 ;;; Code:
 
-(require 'names)
 
-
-;; namespacing using names.el:
-;;;###autoload
-(define-namespace fill-function-arguments-
-
-;; Tell names that it's ok to expand things inside these threading macros.
-:functionlike-macros (-->)
-
-(defcustom fall-through-to-fill-paragraph
+(defcustom fill-function-arguments-fall-through-to-fill-paragraph
   t
   "If true dwim will fill paragraphs when in comments or strings"
   :group 'fill-function-arguments)
 
-(defcustom first-argument-same-line
+(defcustom fill-function-arguments-first-argument-same-line
   nil
   "If true keep the first argument on the same line as the opening paren (e.g. as needed by xml tags)"
   :group 'fill-function-arguments
   )
 
-(defcustom second-argument-same-line
+(defcustom fill-function-arguments-second-argument-same-line
   nil
   "If true keep the second argument on the same line as the first argument.
 
@@ -43,13 +34,13 @@ e.g. as used in lisps like `(foo x
   :group 'fill-function-arguments
   )
 
-(defcustom last-argument-same-line
+(defcustom fill-function-arguments-last-argument-same-line
   nil
   "If true keep the last argument on the same line as the closing paren (e.g. as done in lisp)"
   :group 'fill-function-arguments
   )
 
-(defcustom argument-separator
+(defcustom fill-function-arguments-argument-separator
   ","
   "Character separating arguments"
   :group 'fill-function-arguments
@@ -59,27 +50,27 @@ e.g. as used in lisps like `(foo x
 
 ;;; Helpers
 
-(defun -in-comment-p ()
+(defun fill-function-arguments--in-comment-p ()
   "Check if we are inside a comment"
   (nth 4 (syntax-ppss)))
 
-(defun -in-docs-p ()
+(defun fill-function-arguments--in-docs-p ()
   "Check if we are inside a string or comment"
   (nth 8 (syntax-ppss)))
 
-(defun -opening-paren-location ()
+(defun fill-function-arguments--opening-paren-location ()
   (nth 1 (syntax-ppss)))
 
-(defun -enclosing-paren ()
+(defun fill-function-arguments--enclosing-paren ()
   "Return the opening parenthesis of the enclosing parens, or nil
         if not inside any parens."
   (let ((ppss (syntax-ppss)))
     (when (nth 1 ppss)
       (char-after (nth 1 ppss)))))
 
-(defun -paren-locations ()
+(defun fill-function-arguments--paren-locations ()
   "Get a pair containing the enclosing parens"
-  (let ((start (-opening-paren-location)))
+  (let ((start (fill-function-arguments--opening-paren-location)))
     (when start
       (cons start
             ;; matching paren
@@ -88,83 +79,80 @@ e.g. as used in lisps like `(foo x
               (forward-sexp)
               (point))))))
 
-(defun -narrow-to-funcall ()
+(defun fill-function-arguments--narrow-to-funcall ()
   (interactive)
-  (let ((l (-paren-locations)))
+  (let ((l (fill-function-arguments--paren-locations)))
     (when l
       (narrow-to-region (car l) (cdr l)))
     t))
 
-(defun -single-line-p()
+(defun fill-function-arguments--single-line-p()
   "Is the current function call on a single line?"
   (equal (line-number-at-pos (point-max)) 1))
 
-(defun -suppress-argument-fill-p ()
-  (and fall-through-to-fill-paragraph
-       (or (-in-comment-p)
-           (-in-docs-p)
+(defun fill-function-arguments--suppress-argument-fill-p ()
+  (and fill-function-arguments-fall-through-to-fill-paragraph
+       (or (fill-function-arguments--in-comment-p)
+           (fill-function-arguments--in-docs-p)
            (and (derived-mode-p 'sgml-mode)
-                (not (equal (-enclosing-paren) ?<))))))
+                (not (equal (fill-function-arguments--enclosing-paren) ?<))))))
 
 
 
 ;;; Main functions
 
-(defun to-single-line ()
+(defun fill-function-arguments-to-single-line ()
   (interactive)
   (save-excursion
     (save-restriction
-      (-narrow-to-funcall)
-      (while (not (-single-line-p))
+      (fill-function-arguments--narrow-to-funcall)
+      (while (not (fill-function-arguments--single-line-p))
         (goto-char (point-max))
         (delete-indentation)))))
 
-(defun to-multi-line ()
+(defun fill-function-arguments-to-multi-line ()
   (interactive)
-  (let ((initial-opening-paren (-opening-paren-location)))
+  (let ((initial-opening-paren (fill-function-arguments--opening-paren-location)))
     (save-excursion
       (save-restriction
-        (-narrow-to-funcall)
+        (fill-function-arguments--narrow-to-funcall)
         (goto-char (point-min))
 
         ;; newline after opening paren
         (forward-char)
-        (when (not first-argument-same-line)
+        (when (not fill-function-arguments-first-argument-same-line)
           (insert "\n"))
 
-        (when second-argument-same-line
+        (when fill-function-arguments-second-argument-same-line
           ;; Just move point after the second argument before we start
-          (search-forward argument-separator nil t))
+          (search-forward fill-function-arguments-argument-separator nil t))
 
         ;; Split the arguments
-        (while (search-forward argument-separator nil t)
+        (while (search-forward fill-function-arguments-argument-separator nil t)
           ;; We have to save the match data here because the functions below
           ;; could (and sometimes do) modify it.
           (let ((saved-match-data (match-data)))
-            (when (save-excursion (and (not (-in-docs-p))
-                                       (equal (-opening-paren-location) initial-opening-paren)))
+            (when (save-excursion (and (not (fill-function-arguments--in-docs-p))
+                                       (equal (fill-function-arguments--opening-paren-location) initial-opening-paren)))
               (set-match-data saved-match-data)
-              (replace-match (concat argument-separator "\n")))))
+              (replace-match (concat fill-function-arguments-argument-separator "\n")))))
 
         ;; Newline before closing paren
-        (when (not last-argument-same-line)
+        (when (not fill-function-arguments-last-argument-same-line)
           (goto-char (point-max))
           (backward-char)
           (insert "\n"))))))
 
-(defun dwim ()
+(defun fill-function-arguments-dwim ()
   (interactive)
   (save-restriction
-    (-narrow-to-funcall)
+    (fill-function-arguments--narrow-to-funcall)
     (cond
-     ((-suppress-argument-fill-p) (fill-paragraph))
-     ((-single-line-p) (to-multi-line))
-     (t (to-single-line)))))
-
+     ((fill-function-arguments--suppress-argument-fill-p) (fill-paragraph))
+     ((fill-function-arguments--single-line-p) (fill-function-arguments-to-multi-line))
+     (t (fill-function-arguments-to-single-line)))))
 
 
-  
-  ) ; end of namespace
 
 (provide 'fill-function-arguments)