[Fix #98] Get rid of instaparse dependency

Author: expez

project.clj

@@ -7,7 +7,6 @@
                  ^:source-dep [http-kit "2.1.19"]
                  ^:source-dep [cheshire "5.4.0"]
                  ^:source-dep [alembic "0.3.2"]
-                 ^:source-dep [instaparse "1.3.6"]
                  ^:source-dep [org.clojure/tools.analyzer.jvm "0.6.6"]
                  ^:source-dep [org.clojure/tools.namespace "0.2.7"]
                  ^:source-dep [org.clojure/tools.reader "0.8.12"]

src/refactor_nrepl/ns/ns_parser.clj

@@ -1,109 +1,66 @@
 (ns refactor-nrepl.ns.ns-parser
-  (:require [clojure.java.io :as io]
-            [instaparse.core :refer [parse parser]]
-            [refactor-nrepl.ns.helpers :refer [get-ns-component]]))
+  "Extracts a list of imports or libspecs from an ns form.  A libspec
+  looks like this:
 
-(defn- parse-form
-  "Form is either (:import..) (:use ..) or (:require ..)"
-  [form]
-  (let [ns-parser (parser
-                   (io/resource "refactor_nrepl/ns/require-or-use-or-import.bnf")
-                   :auto-whitespace :comma)]
-    (parse ns-parser (str form))))
+  {:ns ns-name
+   :as alias
+   :refer [referred symbols here] ;; or :all
+   :rename {:rename :spec}
+   :only [only these symbols]}"
+  (:require [refactor-nrepl.ns.helpers :refer [get-ns-component prefix-form?]]))
 
-(defn- add-prefix-to-libspec
-  [prefix libspec]
-  (if (sequential? libspec)
-    (let [suffix (second libspec)]
-      (assoc libspec 0 :libspec-with-opts
-             1 (str prefix "." suffix)))
-    (str prefix "." libspec)))
-
-(defn- use-to-refer-all
+(defn- process-libspec
   [libspec]
-  (if (nil? (:refer libspec))
-    (update-in libspec [:refer] (constantly :all))
-    libspec))
-
-(defmulti parse-libspec first)
-
-(defn- extract-referred [libspec]
-  (let [refer (some->> libspec (drop-while #(not= % ":refer")) second)]
-    (if (sequential? refer)
-      (map symbol (rest refer))
-      (when refer
-        :all))))
-
-(defn- extract-rename-spec [libspec]
-  (some->> libspec
-           (drop-while #(not= % ":rename"))
-           second
-           rest
-           (map symbol)
-           (apply hash-map)))
-
-(defmethod parse-libspec :libspec-with-opts
-  [[_ ns & libspec]]
-  {:ns (symbol ns)
-   :as (some->> libspec (drop-while #(not= % ":as")) second symbol)
-   :refer (extract-referred libspec)
-   :rename (extract-rename-spec libspec)
-   :only (some->> libspec (drop-while #(not= % ":only")) second rest)
-   :flags (some->> libspec (filter #{":reload" ":reload-all" ":verbose"}))})
-
-(defmethod parse-libspec :libspec-no-opts
-  [[_ ns]]
-  {:ns (symbol ns)})
-
-(defmethod parse-libspec :prefix-libspec
-  [[_ prefix & libspecs]]
-  (->> libspecs
-       (map (partial add-prefix-to-libspec prefix))
-       (map parse-libspec)))
-
-(defn- extract-libspecs
-  [form]
-  (flatten
-   (let [parse-tree (rest (second (parse-form form)))]
-     (for [libspec parse-tree]
-       (parse-libspec libspec)))))
-
-(defmulti parse-import first)
-
-(defmethod parse-import :class
-  [import]
-  (second import))
-
-(defn- add-package-prefix-to-class
-  [prefix [_ class-name :as class]]
-  (assoc class 1 (str prefix "." class-name)))
-
-(defmethod parse-import :classes-with-prefix
-  [[_ prefix & classes]]
-  (->> classes
-       (map (partial add-package-prefix-to-class prefix))
-       (map parse-import)))
-
-(defn- extract-imports
-  [form]
-  (let [parse-tree (rest (second (parse-form form)))]
-    (for [import parse-tree]
-      (parse-import import))))
-
-(defn- extract-used [use-form]
-  (some->>  use-form
-            extract-libspecs
-            (map use-to-refer-all)))
-
-(defn- extract-requires [require-form]
-  (some-> require-form
-          extract-libspecs))
+  (if (vector? libspec)
+    (let [[ns & specs] libspec
+          extract-spec (fn [spec](->> specs (drop-while #(not= % spec)) second))]
+      (into {:ns ns} (map vec (partition 2 specs))))
+    {:ns (symbol libspec)}))
+
+(defn- expand-prefix-specs
+  "Eliminate prefix vectors."
+  [libspecs]
+  (let [add-prefix (fn add-prefix [prefix libspec]
+                     (if (vector? libspec)
+                       (apply vector
+                         (str prefix "." (first libspec))
+                         (rest libspec))
+                       (str prefix "." libspec)))
+        normalize-libspec-vector (fn [libspec]
+                                   (if (prefix-form? libspec)
+                                     (let [prefix (first libspec)]
+                                       (map (partial add-prefix prefix)
+                                            (rest libspec)))
+                                     [libspec]))]
+    (mapcat normalize-libspec-vector libspecs)))
+
+(defn- use-to-refer-all [use-specs]
+  (map (fn [use-spec] (if (vector? use-spec)
+                        (if (prefix-form? use-spec)
+                          [(first use-spec) (map #(conj % :refer :all))]
+                          (conj use-spec :refer :all))
+                        [use-spec :refer :all]))
+       use-specs))
 
 (defn get-libspecs [ns-form]
-  (concat
-   (extract-used (get-ns-component ns-form :use))
-   (extract-requires (get-ns-component ns-form :require))))
+  (->> (get-ns-component ns-form :use)
+       rest ; drop :use keyword
+       use-to-refer-all
+       (into (rest (get-ns-component ns-form :require)))
+       expand-prefix-specs
+       (map process-libspec)
+       distinct))
 
 (defn get-imports [ns-form]
-  (some-> (get-ns-component ns-form :import) extract-imports
-          flatten))
+  (let [expand-prefix-specs (fn [import-spec]
+                              (if (vector? import-spec)
+                                (let [package (first import-spec)]
+                                  (map (fn [class-name]
+                                         (str package "." class-name))
+                                       (rest import-spec)))
+                                import-spec))]
+    (some->> (get-ns-component ns-form :import)
+             rest ; drop :import
+             (map expand-prefix-specs)
+             flatten
+             distinct)))

src/refactor_nrepl/ns/rebuild.clj

@@ -121,7 +121,7 @@
                     [:refer (if (sequential? refer)
                               (vec (sort-referred-symbols refer))
                               refer)])
-                  (when rename [:rename (:rename libspec)])
+                  (when rename [:rename (into (sorted-map) (:rename libspec))])
                   flags))))
 
 (defn- create-libspec-vectors-without-prefix

test/resources/ns1_cleaned_no_indentation

@@ -9,7 +9,7 @@
 (:require [clojure data edn xml
 [instant :as inst]
 [pprint :refer [cl-format formatter get-pretty-writer]]
-[string :refer :all :rename {reverse bar, replace foo}]
+[string :refer :all :rename {replace foo, reverse bar}]
 [test :refer :all]
 [walk :refer [postwalk prewalk]]]
 clojure.test.junit)