├── .gitignore ├── CHANGELOG.md ├── LICENSE ├── README.md ├── project.clj ├── src ├── cljsee │ ├── core.clj │ └── parse.clj └── leiningen │ └── cljsee.clj ├── test-projects └── testproj1 │ ├── README.md │ ├── project.clj │ ├── src │ └── cljc │ │ └── testproj1 │ │ └── core.cljc │ └── test │ └── cljc │ └── testproj1 │ └── core_test.clj └── test └── cljsee └── core_test.clj /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /classes 3 | /checkouts 4 | pom.xml 5 | pom.xml.asc 6 | *.jar 7 | *.class 8 | /.lein-* 9 | /.nrepl-port 10 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | Change Log 2 | ========== 3 | 4 | ## 0.1.1-SNAPSHOT - [Unreleased] 5 | 6 | ### Fixed 7 | - Now can parse files with `::a/b` form of keywords. (thanks @bendlas) 8 | 9 | ## 0.1.0 - 2016-06-14 10 | 11 | [Unreleased]: https://github.com/aengelberg/cljsee/compare/0.1.0...HEAD 12 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC 2 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM 3 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 4 | 5 | 1. DEFINITIONS 6 | 7 | "Contribution" means: 8 | 9 | a) in the case of the initial Contributor, the initial code and 10 | documentation distributed under this Agreement, and 11 | 12 | b) in the case of each subsequent Contributor: 13 | 14 | i) changes to the Program, and 15 | 16 | ii) additions to the Program; 17 | 18 | where such changes and/or additions to the Program originate from and are 19 | distributed by that particular Contributor. A Contribution 'originates' from 20 | a Contributor if it was added to the Program by such Contributor itself or 21 | anyone acting on such Contributor's behalf. Contributions do not include 22 | additions to the Program which: (i) are separate modules of software 23 | distributed in conjunction with the Program under their own license 24 | agreement, and (ii) are not derivative works of the Program. 25 | 26 | "Contributor" means any person or entity that distributes the Program. 27 | 28 | "Licensed Patents" mean patent claims licensable by a Contributor which are 29 | necessarily infringed by the use or sale of its Contribution alone or when 30 | combined with the Program. 31 | 32 | "Program" means the Contributions distributed in accordance with this 33 | Agreement. 34 | 35 | "Recipient" means anyone who receives the Program under this Agreement, 36 | including all Contributors. 37 | 38 | 2. GRANT OF RIGHTS 39 | 40 | a) Subject to the terms of this Agreement, each Contributor hereby grants 41 | Recipient a non-exclusive, worldwide, royalty-free copyright license to 42 | reproduce, prepare derivative works of, publicly display, publicly perform, 43 | distribute and sublicense the Contribution of such Contributor, if any, and 44 | such derivative works, in source code and object code form. 45 | 46 | b) Subject to the terms of this Agreement, each Contributor hereby grants 47 | Recipient a non-exclusive, worldwide, royalty-free patent license under 48 | Licensed Patents to make, use, sell, offer to sell, import and otherwise 49 | transfer the Contribution of such Contributor, if any, in source code and 50 | object code form. This patent license shall apply to the combination of the 51 | Contribution and the Program if, at the time the Contribution is added by the 52 | Contributor, such addition of the Contribution causes such combination to be 53 | covered by the Licensed Patents. The patent license shall not apply to any 54 | other combinations which include the Contribution. No hardware per se is 55 | licensed hereunder. 56 | 57 | c) Recipient understands that although each Contributor grants the licenses 58 | to its Contributions set forth herein, no assurances are provided by any 59 | Contributor that the Program does not infringe the patent or other 60 | intellectual property rights of any other entity. Each Contributor disclaims 61 | any liability to Recipient for claims brought by any other entity based on 62 | infringement of intellectual property rights or otherwise. As a condition to 63 | exercising the rights and licenses granted hereunder, each Recipient hereby 64 | assumes sole responsibility to secure any other intellectual property rights 65 | needed, if any. For example, if a third party patent license is required to 66 | allow Recipient to distribute the Program, it is Recipient's responsibility 67 | to acquire that license before distributing the Program. 68 | 69 | d) Each Contributor represents that to its knowledge it has sufficient 70 | copyright rights in its Contribution, if any, to grant the copyright license 71 | set forth in this Agreement. 72 | 73 | 3. REQUIREMENTS 74 | 75 | A Contributor may choose to distribute the Program in object code form under 76 | its own license agreement, provided that: 77 | 78 | a) it complies with the terms and conditions of this Agreement; and 79 | 80 | b) its license agreement: 81 | 82 | i) effectively disclaims on behalf of all Contributors all warranties and 83 | conditions, express and implied, including warranties or conditions of title 84 | and non-infringement, and implied warranties or conditions of merchantability 85 | and fitness for a particular purpose; 86 | 87 | ii) effectively excludes on behalf of all Contributors all liability for 88 | damages, including direct, indirect, special, incidental and consequential 89 | damages, such as lost profits; 90 | 91 | iii) states that any provisions which differ from this Agreement are offered 92 | by that Contributor alone and not by any other party; and 93 | 94 | iv) states that source code for the Program is available from such 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on 96 | or through a medium customarily used for software exchange. 97 | 98 | When the Program is made available in source code form: 99 | 100 | a) it must be made available under this Agreement; and 101 | 102 | b) a copy of this Agreement must be included with each copy of the Program. 103 | 104 | Contributors may not remove or alter any copyright notices contained within 105 | the Program. 106 | 107 | Each Contributor must identify itself as the originator of its Contribution, 108 | if any, in a manner that reasonably allows subsequent Recipients to identify 109 | the originator of the Contribution. 110 | 111 | 4. COMMERCIAL DISTRIBUTION 112 | 113 | Commercial distributors of software may accept certain responsibilities with 114 | respect to end users, business partners and the like. While this license is 115 | intended to facilitate the commercial use of the Program, the Contributor who 116 | includes the Program in a commercial product offering should do so in a 117 | manner which does not create potential liability for other Contributors. 118 | Therefore, if a Contributor includes the Program in a commercial product 119 | offering, such Contributor ("Commercial Contributor") hereby agrees to defend 120 | and indemnify every other Contributor ("Indemnified Contributor") against any 121 | losses, damages and costs (collectively "Losses") arising from claims, 122 | lawsuits and other legal actions brought by a third party against the 123 | Indemnified Contributor to the extent caused by the acts or omissions of such 124 | Commercial Contributor in connection with its distribution of the Program in 125 | a commercial product offering. The obligations in this section do not apply 126 | to any claims or Losses relating to any actual or alleged intellectual 127 | property infringement. In order to qualify, an Indemnified Contributor must: 128 | a) promptly notify the Commercial Contributor in writing of such claim, and 129 | b) allow the Commercial Contributor tocontrol, and cooperate with the 130 | Commercial Contributor in, the defense and any related settlement 131 | negotiations. The Indemnified Contributor may participate in any such claim 132 | at its own expense. 133 | 134 | For example, a Contributor might include the Program in a commercial product 135 | offering, Product X. That Contributor is then a Commercial Contributor. If 136 | that Commercial Contributor then makes performance claims, or offers 137 | warranties related to Product X, those performance claims and warranties are 138 | such Commercial Contributor's responsibility alone. Under this section, the 139 | Commercial Contributor would have to defend claims against the other 140 | Contributors related to those performance claims and warranties, and if a 141 | court requires any other Contributor to pay any damages as a result, the 142 | Commercial Contributor must pay those damages. 143 | 144 | 5. NO WARRANTY 145 | 146 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON 147 | AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER 148 | EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR 149 | CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A 150 | PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the 151 | appropriateness of using and distributing the Program and assumes all risks 152 | associated with its exercise of rights under this Agreement , including but 153 | not limited to the risks and costs of program errors, compliance with 154 | applicable laws, damage to or loss of data, programs or equipment, and 155 | unavailability or interruption of operations. 156 | 157 | 6. DISCLAIMER OF LIABILITY 158 | 159 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY 160 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, 161 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION 162 | LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 163 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 164 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE 165 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY 166 | OF SUCH DAMAGES. 167 | 168 | 7. GENERAL 169 | 170 | If any provision of this Agreement is invalid or unenforceable under 171 | applicable law, it shall not affect the validity or enforceability of the 172 | remainder of the terms of this Agreement, and without further action by the 173 | parties hereto, such provision shall be reformed to the minimum extent 174 | necessary to make such provision valid and enforceable. 175 | 176 | If Recipient institutes patent litigation against any entity (including a 177 | cross-claim or counterclaim in a lawsuit) alleging that the Program itself 178 | (excluding combinations of the Program with other software or hardware) 179 | infringes such Recipient's patent(s), then such Recipient's rights granted 180 | under Section 2(b) shall terminate as of the date such litigation is filed. 181 | 182 | All Recipient's rights under this Agreement shall terminate if it fails to 183 | comply with any of the material terms or conditions of this Agreement and 184 | does not cure such failure in a reasonable period of time after becoming 185 | aware of such noncompliance. If all Recipient's rights under this Agreement 186 | terminate, Recipient agrees to cease use and distribution of the Program as 187 | soon as reasonably practicable. However, Recipient's obligations under this 188 | Agreement and any licenses granted by Recipient relating to the Program shall 189 | continue and survive. 190 | 191 | Everyone is permitted to copy and distribute copies of this Agreement, but in 192 | order to avoid inconsistency the Agreement is copyrighted and may only be 193 | modified in the following manner. The Agreement Steward reserves the right to 194 | publish new versions (including revisions) of this Agreement from time to 195 | time. No one other than the Agreement Steward has the right to modify this 196 | Agreement. The Eclipse Foundation is the initial Agreement Steward. The 197 | Eclipse Foundation may assign the responsibility to serve as the Agreement 198 | Steward to a suitable separate entity. Each new version of the Agreement will 199 | be given a distinguishing version number. The Program (including 200 | Contributions) may always be distributed subject to the version of the 201 | Agreement under which it was received. In addition, after a new version of 202 | the Agreement is published, Contributor may elect to distribute the Program 203 | (including its Contributions) under the new version. Except as expressly 204 | stated in Sections 2(a) and 2(b) above, Recipient receives no rights or 205 | licenses to the intellectual property of any Contributor under this 206 | Agreement, whether expressly, by implication, estoppel or otherwise. All 207 | rights in the Program not expressly granted under this Agreement are 208 | reserved. 209 | 210 | This Agreement is governed by the laws of the State of Washington and the 211 | intellectual property laws of the United States of America. No party to this 212 | Agreement will bring a legal action under this Agreement more than one year 213 | after the cause of action arose. Each party waives its rights to a jury trial 214 | in any resulting litigation. 215 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # cljsee 2 | 3 | [![CircleCI](https://circleci.com/gh/aengelberg/cljsee.svg?style=svg)](https://circleci.com/gh/aengelberg/cljsee) 4 | 5 | Cljsee is a Leiningen plugin that aims to help library authors to write portable code in the `.cljc` format that can be used by projects that run Clojure 1.6 or below. It accomplishes this by parsing the cljc conditionals as a compile-time step and producing `.clj` and `.cljs` files with only the relevant code. 6 | 7 | Cljsee performs a very similar role to the now-deprecated [cljx](https://github.com/lynaghk/cljx) plugin (and I've intentionally modeled cljsee's build configuration after cljx's syntax to make it easy to switch over). But users of cljsee have access to the modern reader conditionals that are official to the Clojure language, including the splicing (`#?@(...)`) conditional, instead of the `#+clj / #+cljs` syntax specific to the cljx plugin. 8 | 9 | Unlike cljx, cljsee does not include nREPL middleware, because as long as your interactive development is done in Clojure 1.7 or above, reader conditionals will properly load at any REPL. 10 | 11 | ## Usage 12 | 13 | In your `project.clj`, include cljsee as a dependency, then add a cljsee build configuration. 14 | 15 | ```clojure 16 | (defproject my-cool-backwards-compatible-project 17 | ... 18 | :plugins [[cljsee "0.1.1-SNAPSHOT"]] 19 | :cljsee {:builds [{:source-paths ["src/"] 20 | :output-path "target/classes" 21 | :rules :clj} 22 | {:source-paths ["src/"] 23 | :output-path "target/generated/cljs" 24 | :rules :cljs}]}) 25 | ``` 26 | 27 | To compile cljc source code once: 28 | ``` 29 | $ lein cljsee once 30 | ``` 31 | 32 | To start a watcher that automatically cross-compiles when files are changed: 33 | ``` 34 | $ lein cljsee auto 35 | ``` 36 | 37 | It's encouraged to add cljsee as a "prep task" so that your cljc files get backported before critical tasks are performed such as jarring or deploying. 38 | 39 | ```clojure 40 | :prep-tasks [["cljsee" "once"]] 41 | ``` 42 | 43 | Note that even though the `cljc` format is no longer in the way of Clojure backwards-compatibility, there are other factors (such as missing features or unfixed bugs) to be careful of when supporting older versions of Clojure. To test that your library works on Clojure 1.6.0, for instance, you can add cljsee builds to your test namespaces like so: 44 | 45 | ```clojure 46 | :profiles {:old-clojure {:dependencies [[org.clojure/clojure "1.6.0"]]} 47 | :test {:cljsee {:builds 48 | [{:source-paths ["test/cljc"] 49 | :output-path "target/classes" 50 | :rules :clj} 51 | {:source-paths ["test/cljc"] 52 | :output-path "target/classes" 53 | :rules :cljs}]}}} 54 | ``` 55 | 56 | To then run your test cases on Clojure 1.6: 57 | 58 | ``` 59 | $ lein with-profile old-clojure test 60 | ``` 61 | 62 | ## Behind the scenes 63 | 64 | Given the following cljc file: 65 | ```clojure 66 | ;; my/ns.cljc 67 | (ns my.ns 68 | (:require [my.helper.ns 69 | #?(:clj :refer 70 | :cljs :refer-macros) 71 | [my-macro]]) 72 | #?(:clj (:import my.class))) 73 | ``` 74 | The following Clojure source is generated: 75 | ```clojure 76 | ;; my/ns.clj 77 | (ns my.ns 78 | (:require [my.helper.ns 79 | :refer 80 | 81 | [my-macro]]) 82 | (:import my.class) ) 83 | ``` 84 | The irrelevant code is "whited out" in the target files. This strategy preserves 85 | the line-column placement of the remaining code, so if errors arise, you can track them down in 86 | your original cljc file. 87 | 88 | ## Credits 89 | 90 | Alex Engelberg is the author of cljsee. Issues and pull requests are welcome. 91 | 92 | Some functions were copied from Kevin Lynagh's cljx library. 93 | 94 | ## License 95 | 96 | Copyright © 2016 Alex Engelberg 97 | 98 | Distributed under the Eclipse Public License, the same as Clojure. 99 | -------------------------------------------------------------------------------- /project.clj: -------------------------------------------------------------------------------- 1 | (defproject cljsee "0.1.1-SNAPSHOT" 2 | :description "Backporting cljc" 3 | :url "http://github.com/aengelberg/cljsee" 4 | :license {:name "Eclipse Public License" 5 | :url "http://www.eclipse.org/legal/epl-v10.html"} 6 | :dependencies [[org.clojure/clojure "1.8.0"] 7 | [org.clojure/tools.reader "0.10.0"] 8 | [watchtower "0.1.1"]]) 9 | -------------------------------------------------------------------------------- /src/cljsee/core.clj: -------------------------------------------------------------------------------- 1 | (ns cljsee.core 2 | (:require [cljsee.parse :refer [process-source-code]] 3 | [clojure.java.io :as io] 4 | [clojure.string :as str]) 5 | (:import java.io.File)) 6 | 7 | ;; Code mostly taken from cljx.core source but modified to find cljc files 8 | 9 | (def ^:private warning-str ";;;;;;;;;;;; This file autogenerated from ") 10 | 11 | (defn- cljc-source-file? 12 | [^File file] 13 | (and (.isFile file) 14 | (.endsWith (.getName file) ".cljc"))) 15 | 16 | (defn- find-cljc-sources-in-dir 17 | [^File dir] 18 | (sort-by #(.getAbsolutePath ^File %) 19 | (filter cljc-source-file? (file-seq (io/file dir))))) 20 | 21 | (defn- relativize 22 | [f root] 23 | (-> root io/file .toURI (.relativize (-> f io/file .toURI)))) 24 | 25 | (defn- destination-path 26 | [source source-path output-dir] 27 | (.getAbsolutePath (io/file output-dir (str (relativize source source-path))))) 28 | 29 | (defn generate 30 | ([options] 31 | (generate options (find-cljc-sources-in-dir (:source-path options)))) 32 | ([{:keys [source-path output-path rules] :as options} files] 33 | (println "Rewriting" source-path "to" output-path 34 | (str "(" rules ")")) 35 | (doseq [f files 36 | :let [result (process-source-code (slurp f) #{rules}) 37 | destination (str/replace (destination-path f source-path output-path) 38 | #"\.[^\.]+$" 39 | (str "." (name rules)))]] 40 | (doto destination 41 | io/make-parents 42 | (spit (with-out-str 43 | (println result) 44 | (print warning-str) 45 | (println (.getPath f)))))))) 46 | 47 | (defn cljsee-compile 48 | ([builds & {:keys [files]}] 49 | (doseq [{:keys [source-paths output-path rules] :as build} builds 50 | p source-paths 51 | :let [abs-path (.getAbsolutePath (io/file p))]] 52 | (if files 53 | (when-let [files (->> files 54 | (filter #(.startsWith (.getAbsolutePath (io/file %)) abs-path)) 55 | seq)] 56 | (generate (assoc build :rules rules :source-path p) files)) 57 | (generate (assoc build :rules rules :source-path p)))))) 58 | -------------------------------------------------------------------------------- /src/cljsee/parse.clj: -------------------------------------------------------------------------------- 1 | (ns cljsee.parse 2 | (:require [clojure.string :as str] 3 | [clojure.tools.reader :as rdr] 4 | [clojure.tools.reader.impl.commons :refer [read-past]] 5 | [clojure.tools.reader.impl.utils :refer [whitespace?]] 6 | [clojure.tools.reader.reader-types :as t])) 7 | 8 | (defn read-while 9 | "Like read-past, but unreads the last char which doesn't satisfy the predicate." 10 | [pred rdr] 11 | (let [ch (read-past pred rdr)] 12 | (t/unread rdr ch))) 13 | 14 | (defrecord ReadEval [expr]) 15 | 16 | (defn starting-line-col-info-double 17 | "Decreases the starting line/col by 2 instead of 1." 18 | [rdr] 19 | (when (t/indexing-reader? rdr) 20 | [(t/get-line-number rdr) (int (- (t/get-column-number rdr) 2))])) 21 | 22 | (defn starting-line-col-info-zero 23 | "Does not decrease the starting line/col, instead of by 1." 24 | [rdr] 25 | (when (t/indexing-reader? rdr) 26 | [(t/get-line-number rdr) (t/get-column-number rdr)])) 27 | 28 | (defn disabled-read-eval 29 | "Evaluate a reader literal" 30 | [rdr _ opts pending-forms] 31 | (let [form (#'rdr/read* rdr true nil opts pending-forms)] 32 | (->ReadEval form))) 33 | 34 | (defn special-read-keyword 35 | "Read ::alias/keywords without namespace context" 36 | [rdr _ opts pending-forms] 37 | (assert (empty? pending-forms)) 38 | (let [tok (#'rdr/read-token rdr \:) 39 | sl (str/index-of tok \/)] 40 | (keyword (when sl (subs tok 1 sl)) 41 | (if sl 42 | (subs tok (inc sl)) 43 | (subs tok 1))))) 44 | 45 | (defrecord ReadCond [splicing form lc-metas]) ; stores a form (:clj 1 :cljs 2 ...) and a list of 46 | ; line-column metadata for each element within. 47 | 48 | (defn special-read-cond 49 | [rdr _ opts pending-forms] 50 | (let [[rc-start-line rc-start-column] (starting-line-col-info-double rdr) 51 | ch (t/read-char rdr) 52 | _ (when-not ch 53 | (t/reader-error rdr "EOF while reading character")) 54 | splicing (= ch \@) 55 | ch (if splicing (t/read-char rdr) ch) 56 | _ (when (and splicing (not @#'rdr/*read-delim*)) 57 | (t/reader-error rdr "cond-splice not in list")) 58 | ch (if (whitespace? ch) (read-past whitespace? rdr) ch) 59 | _ (when-not ch 60 | (t/reader-error rdr "EOF while reading character")) 61 | _ (when (not= ch \() 62 | (throw (RuntimeException. "read-cond body must be a list")))] 63 | (binding [rdr/*suppress-read* true 64 | rdr/*read-delim* true] 65 | (loop [forms [] 66 | lc-metas []] 67 | (read-while whitespace? rdr) 68 | (let [[form-start-line form-start-column] (starting-line-col-info-zero rdr) 69 | form (#'rdr/read* rdr false @#'rdr/READ_EOF \) opts pending-forms) 70 | [form-end-line form-end-column] (#'rdr/ending-line-col-info rdr)] 71 | (if (identical? form @#'rdr/READ_FINISHED) 72 | (let [[rc-end-line rc-end-column] (#'rdr/ending-line-col-info rdr)] 73 | (with-meta 74 | (->ReadCond splicing 75 | forms 76 | lc-metas) 77 | {:line rc-start-line 78 | :column rc-start-column 79 | :end-line rc-end-line 80 | :end-column rc-end-column})) 81 | (if (identical? form @#'rdr/READ_EOF) 82 | (t/reader-error rdr "EOF while reading" 83 | (when rc-start-line 84 | (str ", starting at line " rc-start-line 85 | " and column " rc-start-column))) 86 | (let [lc-meta {:line form-start-line 87 | :column form-start-column 88 | :end-line form-end-line 89 | :end-column form-end-column}] 90 | (recur (conj forms form) 91 | (conj lc-metas lc-meta)))))))))) 92 | 93 | (defn modified-read-string 94 | [s] 95 | (with-redefs [rdr/read-eval disabled-read-eval 96 | rdr/read-keyword special-read-keyword 97 | rdr/read-cond special-read-cond] 98 | (let [rdr (t/indexing-push-back-reader s)] 99 | (->> #(rdr/read {:read-cond :preserve :eof ::eof} rdr) 100 | repeatedly 101 | (take-while #(not= % ::eof)) 102 | doall)))) 103 | 104 | (defn find-read-conds 105 | "Returns all of wrapped reader-conditional constructs within a form." 106 | [form] 107 | (let [read-conds (atom ())] 108 | (clojure.walk/prewalk (fn [form] 109 | (when (instance? ReadCond form) 110 | (swap! read-conds conj form)) 111 | (if (or (instance? ReadEval form) 112 | (instance? ReadCond form)) 113 | ;; turn records -> maps so we can walk properly 114 | (into {} form) 115 | form)) 116 | form) 117 | @read-conds)) 118 | 119 | (defn curry-line-col->index 120 | "Takes a string, and returns a function that takes a line and col and returns a character index." 121 | [str] 122 | (let [lines (re-seq #".*\r?\n?" str) 123 | line-num->index (loop [lines lines 124 | line-num 1 125 | num-chars-so-far 0 126 | table {}] 127 | (if (empty? lines) 128 | table 129 | (recur (rest lines) 130 | (inc line-num) 131 | (+ num-chars-so-far (count (first lines))) 132 | (assoc table line-num num-chars-so-far))))] 133 | (fn [line col] 134 | (+ (line-num->index line) (dec col))))) 135 | 136 | (defn white-out-str! 137 | "\"whites out\" the given range in the text, i.e. converts all non-space characters to spaces 138 | (preserving other whitespace characters, including newlines)." 139 | [^StringBuilder text start end] 140 | (.replace text start end (str/replace (.subSequence text start end) #"\S" " "))) 141 | 142 | (defn pick-form-from-read-cond! 143 | [^StringBuilder text rc features lc->i] 144 | (let [{rc-start-line :line 145 | rc-end-line :end-line 146 | rc-start-column :column 147 | rc-end-column :end-column} (meta rc) 148 | the-list (:form rc) 149 | available-features (map first (partition 2 the-list)) 150 | target-feature (or (some features available-features) :default) 151 | range-to-keep (first (for [[[k v] [_ m]] (map vector 152 | (partition 2 the-list) 153 | (partition 2 (:lc-metas rc))) 154 | :when (= k target-feature)] 155 | m)) 156 | {form-start-line :line 157 | form-end-line :end-line 158 | form-start-column :column 159 | form-end-column :end-column} range-to-keep] 160 | (cond 161 | (not range-to-keep) 162 | (doto text 163 | (white-out-str! (lc->i rc-start-line rc-start-column) 164 | (lc->i rc-end-line rc-end-column))) 165 | 166 | (not (:splicing rc)) 167 | ;; read cond NOT splicing #?(...) 168 | (doto text 169 | (white-out-str! (lc->i rc-start-line rc-start-column) 170 | (lc->i form-start-line form-start-column)) 171 | (white-out-str! (lc->i form-end-line form-end-column) 172 | (lc->i rc-end-line rc-end-column))) 173 | 174 | :else 175 | ;; read cond splicing #?@(...) 176 | (doto text 177 | (white-out-str! (lc->i rc-start-line rc-start-column) 178 | (inc (lc->i form-start-line form-start-column))) 179 | (white-out-str! (dec (lc->i form-end-line form-end-column)) 180 | (lc->i rc-end-line rc-end-column)))))) 181 | 182 | (defn process-source-code 183 | [code features] 184 | (let [sb (StringBuilder. code) 185 | lc->i (curry-line-col->index code) 186 | data (modified-read-string code) 187 | readconds (find-read-conds data)] 188 | (doseq [rc readconds] 189 | (pick-form-from-read-cond! sb rc features lc->i)) 190 | (str sb))) 191 | -------------------------------------------------------------------------------- /src/leiningen/cljsee.clj: -------------------------------------------------------------------------------- 1 | (ns leiningen.cljsee 2 | (:require cljsee.core 3 | [watchtower.core :as wt])) 4 | 5 | (def no-opts-warning "You need a :cljsee entry in your project.clj! See the cljsee docs for more info.") 6 | 7 | (defn- once 8 | "Transform .cljc files once and then exit." 9 | [project builds] 10 | (cljsee.core/cljsee-compile builds)) 11 | 12 | (defn- auto 13 | "Watch .cljc files and transform them after any changes." 14 | [project builds] 15 | (let [dirs (set (flatten (map :source-paths builds)))] 16 | (println "Watching" (vec dirs) "for changes.") 17 | (-> (wt/watcher* dirs) 18 | (wt/file-filter (wt/extensions :cljc)) 19 | (wt/rate 250) 20 | (wt/on-change (fn [files] 21 | (cljsee.core/cljsee-compile builds :files files))) 22 | (wt/watch)))) 23 | 24 | (defn cljsee 25 | "Statically transform .cljc files into Clojure and ClojureScript sources." 26 | {:subtasks [#'once #'auto]} 27 | ([project] (cljsee project "once")) 28 | ([project subtask] 29 | (if-let [opts (:cljsee project)] 30 | (if-let [{builds :builds} opts] 31 | (case subtask 32 | "once" (once project builds) 33 | "auto" (auto project builds))) 34 | (println no-opts-warning)))) 35 | -------------------------------------------------------------------------------- /test-projects/testproj1/README.md: -------------------------------------------------------------------------------- 1 | # cljsee-test 2 | 3 | A Clojure library designed to ... well, that part is up to you. 4 | 5 | ## Usage 6 | 7 | FIXME 8 | 9 | ## License 10 | 11 | Copyright © 2015 FIXME 12 | 13 | Distributed under the Eclipse Public License either version 1.0 or (at 14 | your option) any later version. 15 | -------------------------------------------------------------------------------- /test-projects/testproj1/project.clj: -------------------------------------------------------------------------------- 1 | (defproject testproj1 "0.1.0-SNAPSHOT" 2 | :description "FIXME: write description" 3 | :url "http://example.com/FIXME" 4 | :license {:name "Eclipse Public License" 5 | :url "http://www.eclipse.org/legal/epl-v10.html"} 6 | :dependencies [[org.clojure/clojure "1.7.0"]] 7 | :plugins [[cljsee "0.1.0-SNAPSHOT"]] 8 | :source-paths ["src/cljc"] 9 | :test-paths ["test/cljc"] 10 | :cljsee {:builds [{:source-paths ["src/cljc"] 11 | :output-path "target/classes" 12 | :rules :clj} 13 | {:source-paths ["src/cljc"] 14 | :output-path "target/classes" 15 | :rules :cljs}]} 16 | :profiles {:test {:cljsee {:builds 17 | [{:source-paths ["test/cljc"] 18 | :output-path "target/classes" 19 | :rules :clj} 20 | {:source-paths ["test/cljc"] 21 | :output-path "target/classes" 22 | :rules :cljs}]}} 23 | :old-clojure {:dependencies [[org.clojure/clojure "1.6.0"]]}} 24 | :prep-tasks [["cljsee" "once"]]) 25 | -------------------------------------------------------------------------------- /test-projects/testproj1/src/cljc/testproj1/core.cljc: -------------------------------------------------------------------------------- 1 | (ns testproj1.core) 2 | 3 | #?(:clj 4 | (defn foo 5 | "I don't do a whole lot." 6 | [x] 7 | (println x "Hello, World!")) 8 | :cljs 9 | (defn foo 10 | "I don't do a whole lot on cljs." 11 | [x] 12 | (println x "Hi world!"))) 13 | -------------------------------------------------------------------------------- /test-projects/testproj1/test/cljc/testproj1/core_test.clj: -------------------------------------------------------------------------------- 1 | (ns testproj1.core-test 2 | (:require [clojure.test :refer :all])) 3 | 4 | (deftest a-test 5 | (testing "FIXME, I fail." 6 | (prn *clojure-version*) 7 | (is (= 1 0)))) 8 | -------------------------------------------------------------------------------- /test/cljsee/core_test.clj: -------------------------------------------------------------------------------- 1 | (ns cljsee.core-test 2 | (:require [clojure.test :refer :all] 3 | [cljsee.parse :refer [process-source-code]])) 4 | 5 | (deftest test-parser 6 | (are [x features y] (= y (process-source-code x features)) 7 | "#?(:a 1 :b 2)" #{:a} 8 | " 1 " 9 | 10 | "#?(:a 1)" #{:a} 11 | " 1 " 12 | 13 | "#?(:a 1)" #{:b} 14 | " " 15 | 16 | "#?(:a 1) #?(:b 2)" #{:a :b} 17 | " 1 2 " 18 | 19 | "#?()" #{:a} 20 | " " 21 | 22 | "#?(:a 1 :b 2 :default 3)" #{:c} 23 | " 3 " 24 | 25 | "#?(:a 1 :default 2)" #{:a :b} 26 | " 1 " 27 | 28 | "#?(:a 1 :default 2)" #{:a} 29 | " 1 " 30 | 31 | "#?(:a #?(:b 1))" #{:a :b} 32 | " 1 " 33 | 34 | "[#?@(:a [1 2] :b [3 4])]" #{:a} 35 | "[ 1 2 ]" 36 | 37 | "[#?@(:a [1 2 3])]" #{:a} 38 | "[ 1 2 3 ]" 39 | 40 | "[#?@(:a [1 2 3])]" #{:b} 41 | "[ ]" 42 | 43 | "[#?@(:a [])]" #{:a} 44 | "[ ]" 45 | 46 | "[#?@(:a [1 2] :default [3 4])]" #{:a} 47 | "[ 1 2 ]" 48 | 49 | "[#?@(:a [1 2] :default [3 4])]" #{:B} 50 | "[ 3 4 ]" 51 | 52 | "#{#?(:a 1)}" #{:a} 53 | "#{ 1 }" 54 | 55 | "#{#?@(:a [1 2])}" #{:a} 56 | "#{ 1 2 }" 57 | 58 | "{#?@(:a [1]) #?@(:a [2 3 4])}" #{:a} 59 | "{ 1 2 3 4 }" 60 | 61 | ;; #= shouldn't evaluate during a parse. (note that this usage of 62 | ;; #= would be problematic in regular cljc code) 63 | "#?(:a #=(/ 1 0) :b #=(/ 1 0))" #{:a} 64 | " #=(/ 1 0) " 65 | 66 | ;; same if we switch it around 67 | "#=(/ #?@(:a [1 0]))" #{:a} 68 | "#=(/ 1 0 )" 69 | 70 | ;; test keywords 71 | "#?(:a :simple-keyword)" #{:a} " :simple-keyword " 72 | "#?(:a :namespaced/keyword)" #{:a} " :namespaced/keyword " 73 | "#?(:a ::alias/keyword)" #{:a} " ::alias/keyword " 74 | "#?(:a :simple-keyword)" #{:B} " " 75 | "#?(:a :namespaced/keyword)" #{:B} " " 76 | "#?(:a ::alias/keyword)" #{:B} " " 77 | ":simple-keyword" #{:a} ":simple-keyword" 78 | ":namespaced/keyword" #{:a} ":namespaced/keyword" 79 | "::alias/keyword" #{:a} "::alias/keyword" 80 | ":2pac" {} ":2pac" 81 | ":2p/ac" {} ":2p/ac" 82 | "::2p/ac" {} "::2p/ac") 83 | 84 | ;; ensure comments don't prevent the readcond from parsing, but we 85 | ;; don't guarantee whether they end up in the result of the parse. 86 | (is (= 'result (read-string 87 | (process-source-code 88 | "#?(#_comment ;another comment 89 | #_#_ more comments 90 | :a ; not quite yet 91 | #_#_#_ here it comes ;; wait for it 92 | result ; <-- there it is! 93 | #_done ) ; bye" 94 | #{:a}))))) 95 | --------------------------------------------------------------------------------