THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial
code and documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program
originate from and are distributed by that particular Contributor. A
Contribution 'originates' from a Contributor if it was added to the
Program by such Contributor itself or anyone acting on such
Contributor's behalf. Contributions do not include additions to the
Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii)
are not derivative works of the Program.
"Contributor" means any person or entity that distributes
the Program.
"Licensed Patents" mean patent claims licensable by a
Contributor which are necessarily infringed by the use or sale of its
Contribution alone or when combined with the Program.
"Program" means the Contributions distributed in accordance
with this Agreement.
"Recipient" means anyone who receives the Program under
this Agreement, including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free copyright license to reproduce, prepare derivative works
of, publicly display, publicly perform, distribute and sublicense the
Contribution of such Contributor, if any, and such derivative works, in
source code and object code form.
b) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free patent license under Licensed Patents to make, use, sell,
offer to sell, import and otherwise transfer the Contribution of such
Contributor, if any, in source code and object code form. This patent
license shall apply to the combination of the Contribution and the
Program if, at the time the Contribution is added by the Contributor,
such addition of the Contribution causes such combination to be covered
by the Licensed Patents. The patent license shall not apply to any other
combinations which include the Contribution. No hardware per se is
licensed hereunder.
c) Recipient understands that although each Contributor
grants the licenses to its Contributions set forth herein, no assurances
are provided by any Contributor that the Program does not infringe the
patent or other intellectual property rights of any other entity. Each
Contributor disclaims any liability to Recipient for claims brought by
any other entity based on infringement of intellectual property rights
or otherwise. As a condition to exercising the rights and licenses
granted hereunder, each Recipient hereby assumes sole responsibility to
secure any other intellectual property rights needed, if any. For
example, if a third party patent license is required to allow Recipient
to distribute the Program, it is Recipient's responsibility to acquire
that license before distributing the Program.
d) Each Contributor represents that to its knowledge it
has sufficient copyright rights in its Contribution, if any, to grant
the copyright license set forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code
form under its own license agreement, provided that:
a) it complies with the terms and conditions of this
Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors
all warranties and conditions, express and implied, including warranties
or conditions of title and non-infringement, and implied warranties or
conditions of merchantability and fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors
all liability for damages, including direct, indirect, special,
incidental and consequential damages, such as lost profits;
iii) states that any provisions which differ from this
Agreement are offered by that Contributor alone and not by any other
party; and
iv) states that source code for the Program is available
from such Contributor, and informs licensees how to obtain it in a
reasonable manner on or through a medium customarily used for software
exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each
copy of the Program.
Contributors may not remove or alter any copyright notices contained
within the Program.
Each Contributor must identify itself as the originator of its
Contribution, if any, in a manner that reasonably allows subsequent
Recipients to identify the originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain
responsibilities with respect to end users, business partners and the
like. While this license is intended to facilitate the commercial use of
the Program, the Contributor who includes the Program in a commercial
product offering should do so in a manner which does not create
potential liability for other Contributors. Therefore, if a Contributor
includes the Program in a commercial product offering, such Contributor
("Commercial Contributor") hereby agrees to defend and
indemnify every other Contributor ("Indemnified Contributor")
against any losses, damages and costs (collectively "Losses")
arising from claims, lawsuits and other legal actions brought by a third
party against the Indemnified Contributor to the extent caused by the
acts or omissions of such Commercial Contributor in connection with its
distribution of the Program in a commercial product offering. The
obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In
order to qualify, an Indemnified Contributor must: a) promptly notify
the Commercial Contributor in writing of such claim, and b) allow the
Commercial Contributor to control, and cooperate with the Commercial
Contributor in, the defense and any related settlement negotiations. The
Indemnified Contributor may participate in any such claim at its own
expense.
For example, a Contributor might include the Program in a commercial
product offering, Product X. That Contributor is then a Commercial
Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor's responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those
performance claims and warranties, and if a court requires any other
Contributor to pay any damages as a result, the Commercial Contributor
must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its
exercise of rights under this Agreement , including but not limited to
the risks and costs of program errors, compliance with applicable laws,
damage to or loss of data, programs or equipment, and unavailability or
interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under
applicable law, it shall not affect the validity or enforceability of
the remainder of the terms of this Agreement, and without further action
by the parties hereto, such provision shall be reformed to the minimum
extent necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the
Program itself (excluding combinations of the Program with other
software or hardware) infringes such Recipient's patent(s), then such
Recipient's rights granted under Section 2(b) shall terminate as of the
date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it
fails to comply with any of the material terms or conditions of this
Agreement and does not cure such failure in a reasonable period of time
after becoming aware of such noncompliance. If all Recipient's rights
under this Agreement terminate, Recipient agrees to cease use and
distribution of the Program as soon as reasonably practicable. However,
Recipient's obligations under this Agreement and any licenses granted by
Recipient relating to the Program shall continue and survive.
Everyone is permitted to copy and distribute copies of this
Agreement, but in order to avoid inconsistency the Agreement is
copyrighted and may only be modified in the following manner. The
Agreement Steward reserves the right to publish new versions (including
revisions) of this Agreement from time to time. No one other than the
Agreement Steward has the right to modify this Agreement. The Eclipse
Foundation is the initial Agreement Steward. The Eclipse Foundation may
assign the responsibility to serve as the Agreement Steward to a
suitable separate entity. Each new version of the Agreement will be
given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the
Agreement under which it was received. In addition, after a new version
of the Agreement is published, Contributor may elect to distribute the
Program (including its Contributions) under the new version. Except as
expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
rights or licenses to the intellectual property of any Contributor under
this Agreement, whether expressly, by implication, estoppel or
otherwise. All rights in the Program not expressly granted under this
Agreement are reserved.
This Agreement is governed by the laws of the State of New York and
the intellectual property laws of the United States of America. No party
to this Agreement will bring a legal action under this Agreement more
than one year after the cause of action arose. Each party waives its
rights to a jury trial in any resulting litigation.
tools.nrepl-tools.nrepl-0.2.13/load-file-test/ 0000775 0000000 0000000 00000000000 13070463361 0021145 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/load-file-test/clojure/ 0000775 0000000 0000000 00000000000 13070463361 0022610 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/load-file-test/clojure/tools/ 0000775 0000000 0000000 00000000000 13070463361 0023750 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/load-file-test/clojure/tools/nrepl/ 0000775 0000000 0000000 00000000000 13070463361 0025070 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/load-file-test/clojure/tools/nrepl/load_file_sample.clj 0000664 0000000 0000000 00000000216 13070463361 0031040 0 ustar 00root root 0000000 0000000 (ns clojure.tools.nrepl.load-file-sample)
(defn dfunction
"Ensure \t that \n the \r various \f escapes \" work \\ as expected \\\""
[]) tools.nrepl-tools.nrepl-0.2.13/pom.xml 0000664 0000000 0000000 00000005732 13070463361 0017660 0 ustar 00root root 0000000 0000000 4.0.0tools.nrepl0.2.13tools.nreplorg.clojurepom.contrib0.2.2Chas Emerickhttp://cemerick.comcemerick@snowtide.com-5scm:git:git@github.com:clojure/tools.nrepl.gitscm:git:git@github.com:clojure/tools.nrepl.gitgit@github.com:clojure/tools.nrepl.gittools.nrepl-0.2.131.2.0trueorg.clojuretools.logging0.2.3truesrc/main/resourcestruesrc/main/clojuremaven-invoker-plugin1.5src/integration${project.build.directory}/integration*/pom.xmltrueclojure:testintegration-testinstallrunorg.apache.maven.pluginsmaven-jar-pluginMETA-INF/MANIFEST.MF
tools.nrepl-tools.nrepl-0.2.13/src/ 0000775 0000000 0000000 00000000000 13070463361 0017123 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/ 0000775 0000000 0000000 00000000000 13070463361 0021446 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.3.0/ 0000775 0000000 0000000 00000000000 13070463361 0023546 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.3.0/pom.xml 0000664 0000000 0000000 00000003167 13070463361 0025072 0 ustar 00root root 0000000 0000000 4.0.0clojure.tools0.0.2-SNAPSHOTnrepl-test-clojure-1.3.0nREPL (Clojure 1.3.0 tests)org.clojureclojure1.3.0@project.groupId@@project.artifactId@@project.version@com.theoryinpractiseclojure-maven-plugin1.3.8@basedir@/src/test/clojure-Dnrepl.basedir=@basedir@test-clojuretesttest tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.4.0/ 0000775 0000000 0000000 00000000000 13070463361 0023547 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.4.0/pom.xml 0000664 0000000 0000000 00000003167 13070463361 0025073 0 ustar 00root root 0000000 0000000 4.0.0clojure.tools0.0.2-SNAPSHOTnrepl-test-clojure-1.4.0nREPL (Clojure 1.4.0 tests)org.clojureclojure1.4.0@project.groupId@@project.artifactId@@project.version@com.theoryinpractiseclojure-maven-plugin1.3.8@basedir@/src/test/clojure-Dnrepl.basedir=@basedir@test-clojuretesttest tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.5.0/ 0000775 0000000 0000000 00000000000 13070463361 0023550 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.5.0/pom.xml 0000664 0000000 0000000 00000004053 13070463361 0025067 0 ustar 00root root 0000000 0000000 4.0.0clojure.tools0.0.2-SNAPSHOTnrepl-test-clojure-1.5.0nREPL (Clojure 1.5.0 tests)org.clojureclojure1.5.0@project.groupId@@project.artifactId@@project.version@falsetruesonatype-nexus-snapshotsSonatype Nexus Snapshotshttps://oss.sonatype.org/content/repositories/snapshotscom.theoryinpractiseclojure-maven-plugin1.3.8@basedir@/src/test/clojure-Dnrepl.basedir=@basedir@test-clojuretesttest
tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.6/ 0000775 0000000 0000000 00000000000 13070463361 0023413 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.6/pom.xml 0000664 0000000 0000000 00000004053 13070463361 0024732 0 ustar 00root root 0000000 0000000 4.0.0clojure.tools0.0.2-SNAPSHOTnrepl-test-clojure-1.6.xnREPL (Clojure 1.6.x tests)org.clojureclojure1.6.0@project.groupId@@project.artifactId@@project.version@falsetruesonatype-nexus-snapshotsSonatype Nexus Snapshotshttps://oss.sonatype.org/content/repositories/snapshotscom.theoryinpractiseclojure-maven-plugin1.3.8@basedir@/src/test/clojure-Dnrepl.basedir=@basedir@test-clojuretesttest
tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.7/ 0000775 0000000 0000000 00000000000 13070463361 0023414 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/integration/clojure-1.7/pom.xml 0000664 0000000 0000000 00000004073 13070463361 0024735 0 ustar 00root root 0000000 0000000 4.0.0clojure.tools0.0.2-SNAPSHOTnrepl-test-clojure-1.7.xnREPL (Clojure 1.7.x tests)org.clojureclojure1.7.0-master-SNAPSHOT@project.groupId@@project.artifactId@@project.version@falsetruesonatype-nexus-snapshotsSonatype Nexus Snapshotshttps://oss.sonatype.org/content/repositories/snapshotscom.theoryinpractiseclojure-maven-plugin1.3.8@basedir@/src/test/clojure-Dnrepl.basedir=@basedir@test-clojuretesttest
tools.nrepl-tools.nrepl-0.2.13/src/main/ 0000775 0000000 0000000 00000000000 13070463361 0020047 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/ 0000775 0000000 0000000 00000000000 13070463361 0021512 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/ 0000775 0000000 0000000 00000000000 13070463361 0023155 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/ 0000775 0000000 0000000 00000000000 13070463361 0024315 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl.clj 0000664 0000000 0000000 00000023267 13070463361 0026141 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey. All rights reserved.
; The use and distribution terms for this software are covered by the
; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
; which can be found in the file epl-v10.html at the root of this distribution.
; By using this software in any fashion, you are agreeing to be bound by
; the terms of this license.
; You must not remove this notice, or any other, from this software.
(ns ^{:doc "High level nREPL client support."
:author "Chas Emerick"}
clojure.tools.nrepl
(:require [clojure.tools.nrepl.transport :as transport]
clojure.set
[clojure.java.io :as io])
(:use [clojure.tools.nrepl.misc :only (uuid)])
(:import clojure.lang.LineNumberingPushbackReader
(java.io Reader StringReader Writer PrintWriter)))
(defn response-seq
"Returns a lazy seq of messages received via the given Transport.
Called with no further arguments, will block waiting for each message.
The seq will end only when the underlying Transport is closed (i.e.
returns nil from `recv`) or if a message takes longer than `timeout`
millis to arrive."
([transport] (response-seq transport Long/MAX_VALUE))
([transport timeout]
(take-while identity (repeatedly #(transport/recv transport timeout)))))
(defn client
"Returns a fn of zero and one argument, both of which return the current head of a single
response-seq being read off of the given client-side transport. The one-arg arity will
send a given message on the transport before returning the seq.
Most REPL interactions are best performed via `message` and `client-session` on top of
a client fn returned from this fn."
[transport response-timeout]
(let [latest-head (atom nil)
update #(swap! latest-head
(fn [[timestamp seq :as head] now]
(if (< timestamp now)
[now %]
head))
; nanoTime appropriate here; looking to maintain ordering, not actual timestamps
(System/nanoTime))
tracking-seq (fn tracking-seq [responses]
(lazy-seq
(if (seq responses)
(let [rst (tracking-seq (rest responses))]
(update rst)
(cons (first responses) rst))
(do (update nil) nil))))
restart #(let [head (-> transport
(response-seq response-timeout)
tracking-seq)]
(reset! latest-head [0 head])
head)]
^{::transport transport ::timeout response-timeout}
(fn this
([] (or (second @latest-head)
(restart)))
([msg]
(transport/send transport msg)
(this)))))
(defn- take-until
"Like (take-while (complement f) coll), but includes the first item in coll that
returns true for f."
[f coll]
(let [[head tail] (split-with (complement f) coll)]
(concat head (take 1 tail))))
(defn- delimited-transport-seq
[client termination-statuses delimited-slots]
(with-meta
(comp (partial take-until (comp #(seq (clojure.set/intersection % termination-statuses))
set
:status))
(let [keys (keys delimited-slots)]
(partial filter #(= delimited-slots (select-keys % keys))))
client
#(merge % delimited-slots))
(-> (meta client)
(update-in [::termination-statuses] (fnil into #{}) termination-statuses)
(update-in [::taking-until] merge delimited-slots))))
(defn message
"Sends a message via [client] with a fixed message :id added to it.
Returns the head of the client's response seq, filtered to include only
messages related to the message :id that will terminate upon receipt of a
\"done\" :status."
[client {:keys [id] :as msg :or {id (uuid)}}]
(let [f (delimited-transport-seq client #{"done"} {:id id})]
(f (assoc msg :id id))))
(defn new-session
"Provokes the creation and retention of a new session, optionally as a clone
of an existing retained session, the id of which must be provided as a :clone
kwarg. Returns the new session's id."
[client & {:keys [clone]}]
(let [resp (first (message client (merge {:op "clone"} (when clone {:session clone}))))]
(or (:new-session resp)
(throw (IllegalStateException.
(str "Could not open new session; :clone response: " resp))))))
(defn client-session
"Returns a function of one argument. Accepts a message that is sent via the
client provided with a fixed :session id added to it. Returns the
head of the client's response seq, filtered to include only
messages related to the :session id that will terminate when the session is
closed."
[client & {:keys [session clone]}]
(let [session (or session (apply new-session client (when clone [:clone clone])))]
(delimited-transport-seq client #{"session-closed"} {:session session})))
(defn combine-responses
"Combines the provided seq of response messages into a single response map.
Certain message slots are combined in special ways:
- only the last :ns is retained
- :value is accumulated into an ordered collection
- :status and :session are accumulated into a set
- string values (associated with e.g. :out and :err) are concatenated"
[responses]
(reduce
(fn [m [k v]]
(case k
(:id :ns) (assoc m k v)
:value (update-in m [k] (fnil conj []) v)
:status (update-in m [k] (fnil into #{}) v)
:session (update-in m [k] (fnil conj #{}) v)
(if (string? v)
(update-in m [k] #(str % v))
(assoc m k v))))
{} (apply concat responses)))
(defn code*
"Returns a single string containing the pr-str'd representations
of the given expressions."
[& expressions]
(apply str (map pr-str expressions)))
(defmacro code
"Expands into a string consisting of the macro's body's forms
(literally, no interpolation/quasiquoting of locals or other
references), suitable for use in an :eval message, e.g.:
{:op :eval, :code (code (+ 1 1) (slurp \"foo.txt\"))}"
[& body]
(apply code* body))
(defn read-response-value
"Returns the provided response message, replacing its :value string with
the result of (read)ing it. Returns the message unchanged if the :value
slot is empty or not a string."
[{:keys [value] :as msg}]
(if-not (string? value)
msg
(try
(assoc msg :value (read-string value))
(catch Exception e
(throw (IllegalStateException. (str "Could not read response value: " value) e))))))
(defn response-values
"Given a seq of responses (as from response-seq or returned from any function returned
by client or client-session), returns a seq of values read from :value slots found
therein."
[responses]
(->> responses
(map read-response-value)
combine-responses
:value))
(defn connect
"Connects to a socket-based REPL at the given host (defaults to localhost) and port,
returning the Transport (by default clojure.tools.nrepl.transport/bencode)
for that connection.
Transports are most easily used with `client`, `client-session`, and
`message`, depending on the semantics desired."
[& {:keys [port host transport-fn] :or {transport-fn transport/bencode
host "localhost"}}]
{:pre [transport-fn port]}
(transport-fn (java.net.Socket. ^String host (int port))))
(defn- ^java.net.URI to-uri
[x]
{:post [(instance? java.net.URI %)]}
(if (string? x)
(java.net.URI. x)
x))
(defn- socket-info
[x]
(let [uri (to-uri x)
port (.getPort uri)]
(merge {:host (.getHost uri)}
(when (pos? port)
{:port port}))))
(def ^{:private false} uri-scheme #(-> (to-uri %) .getScheme .toLowerCase))
(defmulti url-connect
"Connects to an nREPL endpoint identified by the given URL/URI. Valid
examples include:
nrepl://192.168.0.12:7889
telnet://localhost:5000
http://your-app-name.heroku.com/repl
This is a multimethod that dispatches on the scheme of the URI provided
(which can be a string or java.net.URI). By default, implementations for
nrepl (corresponding to using the default bencode transport) and
telnet (using the clojure.tools.nrepl.transport/tty transport) are
registered. Alternative implementations may add support for other schemes,
such as HTTP, HTTPS, JMX, existing message queues, etc."
uri-scheme)
;; TODO oh so ugly
(defn- add-socket-connect-method!
[protocol connect-defaults]
(defmethod url-connect protocol
[uri]
(apply connect (mapcat identity
(merge connect-defaults
(socket-info uri))))))
(add-socket-connect-method! "nrepl" {:transport-fn transport/bencode
:port 7888})
(add-socket-connect-method! "telnet" {:transport-fn transport/tty})
(defmethod url-connect :default
[uri]
(throw (IllegalArgumentException.
(format "No nREPL support known for scheme %s, url %s" (uri-scheme uri) uri))))
(def ^{:doc "Current version of nREPL, map of :major, :minor, :incremental, and :qualifier."}
version
(when-let [in (.getResourceAsStream (class connect) "/clojure/tools/nrepl/version.txt")]
(with-open [^java.io.BufferedReader reader (io/reader in)]
(let [version-string (-> reader .readLine .trim)]
(assoc (->> version-string
(re-find #"(\d+)\.(\d+)\.(\d+)-?(.*)")
rest
(zipmap [:major :minor :incremental :qualifier]))
:version-string version-string)))))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/ 0000775 0000000 0000000 00000000000 13070463361 0025435 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/ack.clj 0000664 0000000 0000000 00000003345 13070463361 0026672 0 ustar 00root root 0000000 0000000
(ns clojure.tools.nrepl.ack
(:require [clojure.tools.nrepl :as repl]
[clojure.tools.nrepl.transport :as t])
(:import (java.util.concurrent Future TimeUnit TimeoutException)))
; could be a lot fancier, but it'll do for now
(def ^{:private true} ack-port-promise (atom nil))
(defn reset-ack-port!
[]
(reset! ack-port-promise (promise))
; save people the misery of ever trying to deref the empty promise in their REPL
nil)
(defn wait-for-ack
"Waits for a presumably just-launched nREPL server to connect and
deliver its port number. Returns that number if it's delivered
within `timeout` ms, otherwise nil. Assumes that `ack`
middleware has been applied to the local nREPL server handler.
Expected usage:
(reset-ack-port!)
(start-server already-running-server-port)
=> (wait-for-ack)
59872 ; the port of the server started via start-server"
[timeout]
(let [^Future f (future @@ack-port-promise)]
(try
; no deref with timeout in 1.2
(.get f timeout TimeUnit/MILLISECONDS)
(catch TimeoutException e))))
(defn handle-ack
[h]
(fn [{:keys [op port transport] :as msg}]
(if (not= op "ack")
(h msg)
(try
(deliver @ack-port-promise port)
(t/send transport {:status :done})))))
; TODO could stand to have some better error handling around all of this
(defn send-ack
[my-port ack-port]
(with-open [^java.io.Closeable transport (repl/connect :port ack-port)]
(let [client (repl/client transport 1000)]
; consume response from the server, solely to let that side
; finish cleanly without (by default) spewing a SocketException when
; the ack client goes away suddenly
(dorun (repl/message client {:op :ack :port my-port})))))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/bencode.clj 0000664 0000000 0000000 00000033444 13070463361 0027536 0 ustar 00root root 0000000 0000000 ;-
; Copyright (c) Meikel Brandmeyer. All rights reserved.
; The use and distribution terms for this software are covered by the
; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
; which can be found in the file epl-v10.html at the root of this distribution.
; By using this software in any fashion, you are agreeing to be bound by
; the terms of this license.
; You must not remove this notice, or any other, from this software.
(ns #^{:author "Meikel Brandmeyer"
:doc "A netstring and bencode implementation for Clojure."}
clojure.tools.nrepl.bencode
(:require [clojure.java.io :as io])
(:import (java.io IOException EOFException ByteArrayOutputStream
InputStream OutputStream PushbackInputStream)
clojure.lang.RT))
;; # Motivation
;;
;; In each and every application, which contacts peer processes via some
;; communication channel, the handling of the communication channel is
;; obviously a central part of the application. Unfortunately introduces
;; handling of buffers of varying sizes often bugs in form of buffer
;; overflows and similar.
;;
;; A strong factor in this situation is of course the protocol which goes
;; over the wire. Depending on its design it might be difficult to estimate
;; the size of the input up front. This introduces more handling of message
;; buffers to accomodate for inputs of varying sizes. This is particularly
;; difficult in languages like C, where there is no bounds checking of array
;; accesses and where errors might go unnoticed for considerable amount of
;; time.
;;
;; To address these issues D. Bernstein developed the so called
;; [netstrings][net]. They are especially designed to allow easy construction
;; of the message buffers, easy and robust parsing.
;;
;; BitTorrent extended this to the [bencode][bc] protocol which also
;; includes ways to encode numbers and collections like lists or maps.
;;
;; *wire* is based on these ideas.
;;
;; [net]: http://cr.yp.to/proto/netstrings.txt
;; [bc]: http://wiki.theory.org/BitTorrentSpecification#Bencoding
;;
;; # Netstrings
;;
;; Now let's start with the basic netstrings. They consist of a byte count,
;; followed a colon and the binary data and a trailing comma. Examples:
;;
;; 13:Hello, World!,
;; 10:Guten Tag!,
;; 0:,
;;
;; The initial byte count allows to efficiently allocate a sufficiently
;; sized message buffer. The trailing comma serves as a hint to detect
;; incorrect netstrings.
;;
;; ## Low-level reading
;;
;; We will need some low-level reading helpers to read the bytes from
;; the input stream. These are `read-byte` as well as `read-bytes`. They
;; are split out, because doing such a simple task as reading a byte is
;; mild catastrophe in Java. So it would add some clutter to the algorithm
;; `read-netstring`.
;;
;; On the other hand they might be also useful elsewhere.
;;
;; To remove some magic numbers from the code below.
(def #^{:const true} i 105)
(def #^{:const true} l 108)
(def #^{:const true} d 100)
(def #^{:const true} comma 44)
(def #^{:const true} minus 45)
;; These two are only used boxed. So we keep them extra here.
(def e 101)
(def colon 58)
(defn #^{:private true} read-byte
#^long [#^InputStream input]
(let [c (.read input)]
(when (neg? c)
(throw (EOFException. "Invalid netstring. Unexpected end of input.")))
;; Here we have a quirk for example. `.read` returns -1 on end of
;; input. However the Java `Byte` has only a range from -128 to 127.
;; How does the fit together?
;;
;; The whole thing is shifted. `.read` actually returns an int
;; between zero and 255. Everything below the value 128 stands
;; for itself. But larger values are actually negative byte values.
;;
;; So we have to do some translation here. `Byte/byteValue` would
;; do that for us, but we want to avoid boxing here.
(if (< 127 c) (- c 256) c)))
(defn #^{:private true :tag "[B"} read-bytes
#^Object [#^InputStream input n]
(let [content (byte-array n)]
(loop [offset (int 0)
len (int n)]
(let [result (.read input content offset len)]
(when (neg? result)
(throw
(EOFException.
"Invalid netstring. Less data available than expected.")))
(when (not= result len)
(recur (+ offset result) (- len result)))))
content))
;; `read-long` is used for reading integers from the stream as well
;; as the byte count prefixes of byte strings. The delimiter is \:
;; for byte count prefixes and \e for integers.
(defn #^{:private true} read-long
#^long [#^InputStream input delim]
(loop [n (long 0)]
;; We read repeatedly a byte from the input…
(let [b (read-byte input)]
;; …and stop at the delimiter.
(cond
(= b minus) (- (read-long input delim))
(= b delim) n
:else (recur (+ (* n (long 10)) (- (long b) (long 48))))))))
;; ## Reading a netstring
;;
;; Let's dive straight into reading a netstring from an `InputStream`.
;;
;; For convenience we split the function into two subfunctions. The
;; public `read-netstring` is the normal entry point, which also checks
;; for the trailing comma after reading the payload data with the
;; private `read-netstring*`.
;;
;; The reason we need the less strict `read-netstring*` is that with
;; bencode we don't have a trailing comma. So a check would not be
;; beneficial here.
;;
;; However the consumer doesn't have to care. `read-netstring` as
;; well as `read-bencode` provide the public entry points, which do
;; the right thing. Although they both may reference the `read-netstring*`
;; underneath.
;;
;; With this in mind we define the inner helper function first.
(declare #^"[B" string>payload
#^String stringpayload` and `stringpayload
[#^String s]
(.getBytes s "UTF-8"))
(defn #^{:private true :tag String} stringpayload (str (alength content))))
(.write (int colon))
(.write content)))
(defn write-netstring
"Write the given binary data to the output stream in form of a classic
netstring."
[#^OutputStream output content]
(doto output
(write-netstring* content)
(.write (int comma))))
;; # Bencode
;;
;; However most of the time we don't want to send simple blobs of data
;; back and forth. The data sent between the communication peers usually
;; have some structure, which has to be carried along the way to the
;; other side. Here [bencode][bc] come into play.
;;
;; Bencode defines additionally to netstrings easily parseable structures
;; for lists, maps and numbers. It allows to communicate information
;; about the data structure to the peer on the other side.
;;
;; ## Tokens
;;
;; The data is encoded in tokens in bencode. There are several types of
;; tokens:
;;
;; * A netstring without trailing comma for string data.
;; * A tag specifiyng the type of the following tokens.
;; The tag may be one of these:
;; * `\i` to encode integers.
;; * `\l` to encode lists of items.
;; * `\d` to encode maps of item pairs.
;; * `\e` to end the a previously started tag.
;;
;; ## Reading bencode
;;
;; Reading bencode encoded data is basically parsing a stream of tokens
;; from the input. Hence we need a read-token helper which allows to
;; retrieve the next token.
(defn #^{:private true} read-token
[#^PushbackInputStream input]
(let [ch (read-byte input)]
(cond
(= (long e) ch) nil
(= i ch) :integer
(= l ch) :list
(= d ch) :map
:else (do
(.unread input (int ch))
(read-netstring* input)))))
;; To read the bencode encoded data we walk a long the sequence of tokens
;; and act according to the found tags.
(declare read-integer read-list read-map)
(defn read-bencode
"Read bencode token from the input stream."
[input]
(let [token (read-token input)]
(case token
:integer (read-integer input)
:list (read-list input)
:map (read-map input)
token)))
;; Of course integers and the collection types are have to treated specially.
;;
;; Integers for example consist of a sequence of decimal digits.
(defn #^{:private true} read-integer
[input]
(read-long input e))
;; *Note:* integers are an ugly special case, which cannot be
;; handled with `read-token` or `read-netstring*`.
;;
;; Lists are just a sequence of other tokens.
(declare token-seq)
(defn #^{:private true} read-list
[input]
(vec (token-seq input)))
;; Maps are sequences of key/value pairs. The keys are always
;; decoded into strings. The values are kept as is.
(defn #^{:private true} read-map
[input]
(->> (token-seq input)
(partition 2)
(map (fn [[k v]] [(string> #(read-bencode input)
repeatedly
(take-while identity)))
;; ## Writing bencode
;;
;; Writing bencode is similar easy as reading it. The main entry point
;; takes a string, map, sequence or integer and writes it according to
;; the rules to the given OutputStream.
(defmulti write-bencode
"Write the given thing to the output stream. “Thing” means here a
string, map, sequence or integer. Alternatively an ByteArray may
be provided whose contents are written as a bytestring. Similar
the contents of a given InputStream are written as a byte string.
Named things (symbols or keywords) are written in the form
'namespace/name'."
(fn [_output thing]
(cond
(instance? (RT/classForName "[B") thing) :bytes
(instance? InputStream thing) :input-stream
(integer? thing) :integer
(string? thing) :string
(symbol? thing) :named
(keyword? thing) :named
(map? thing) :map
(or (nil? thing) (coll? thing) (.isArray (class thing))) :list
:else (type thing))))
(defmethod write-bencode :default
[output x]
(throw (IllegalArgumentException. (str "Cannot write value of type " (class x)))))
;; The following methods should be pretty straight-forward.
;;
;; The easiest case is of course when we already have a byte array.
;; We can simply pass it on to the underlying machinery.
(defmethod write-bencode :bytes
[output bytes]
(write-netstring* output bytes))
;; For strings we simply write the string as a netstring without
;; trailing comma after encoding the string as UTF-8 bytes.
(defmethod write-bencode :string
[output string]
(write-netstring* output (string>payload string)))
;; Streaming does not really work, since we need to know the
;; number of bytes to write upfront. So we read in everything
;; for InputStreams and pass on the byte array.
(defmethod write-bencode :input-stream
[output stream]
(let [bytes (ByteArrayOutputStream.)]
(io/copy stream bytes)
(write-netstring* output (.toByteArray bytes))))
;; Integers are again the ugly special case.
(defmethod write-bencode :integer
[#^OutputStream output n]
(doto output
(.write (int i))
(.write (string>payload (str n)))
(.write (int e))))
;; Symbols and keywords are converted to a string of the
;; form 'namespace/name' or just 'name' in case its not
;; qualified. We do not add colons for keywords since the
;; other side might not have the notion of keywords.
(defmethod write-bencode :named
[output thing]
(let [nspace (namespace thing)
name (name thing)]
(->> (str (when nspace (str nspace "/")) name)
string>payload
(write-netstring* output))))
;; Lists as well as maps work recursively to print their elements.
(defmethod write-bencode :list
[#^OutputStream output lst]
(.write output (int l))
(doseq [elt lst]
(write-bencode output elt))
(.write output (int e)))
;; However, maps are a bit special because their keys are sorted
;; lexicographically based on their byte string represantation.
(declare lexicographically)
(defmethod write-bencode :map
[#^OutputStream output m]
(let [translation (into {} (map (juxt string>payload identity) (keys m)))
key-strings (sort lexicographically (keys translation))
>value (comp m translation)]
(.write output (int d))
(doseq [k key-strings]
(write-netstring* output k)
(write-bencode output (>value k)))
(.write output (int e))))
;; However, since byte arrays are not `Comparable` we need a custom
;; comparator which we can feed to `sort`.
(defn #^{:private true} lexicographically
[#^"[B" a #^"[B" b]
(let [alen (alength a)
blen (alength b)
len (min alen blen)]
(loop [i 0]
(if (== i len)
(- alen blen)
(let [x (- (int (aget a i)) (int (aget b i)))]
(if (zero? x)
(recur (inc i))
x))))))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/cmdline.clj 0000664 0000000 0000000 00000006356 13070463361 0027554 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey. All rights reserved.
; The use and distribution terms for this software are covered by the
; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
; which can be found in the file epl-v10.html at the root of this distribution.
; By using this software in any fashion, you are agreeing to be bound by
; the terms of this license.
; You must not remove this notice, or any other, from this software.
(ns #^{:doc "A proof-of-concept command-line client for nREPL. Please see
e.g. reply for a proper command-line nREPL client @
https://github.com/trptcolin/reply/"
:author "Chas Emerick"}
clojure.tools.nrepl.cmdline
(:require [clojure.tools.nrepl :as repl]
[clojure.tools.nrepl.transport :as transport])
(:use (clojure.tools.nrepl [server :only (start-server)]
[ack :only (send-ack)])))
(defn- ensure-newline
[s]
(if (= "\n" (last s))
s
(str s \newline)))
(def colored-output
{:err #(binding [*out* *err*]
(print "\033[31m")
(print %)
(print "\033[m")
(flush))
:out print
:value (fn [x]
(print "\033[34m")
(print x)
(print "\033[m")
(flush))})
(defn- run-repl
([port] (run-repl port nil))
([port {:keys [prompt err out value]
:or {prompt #(print (str % "=> "))
err println
out println
value println}}]
(let [transport (repl/connect :host "localhost" :port port)
client (repl/client-session (repl/client transport Long/MAX_VALUE))
ns (atom "user")
{:keys [major minor incremental qualifier]} *clojure-version*]
(println "network-repl")
(println (str "Clojure " (clojure-version)))
(loop []
(prompt @ns)
(flush)
(doseq [res (repl/message client {:op "eval" :code (pr-str (read))})]
(when (:value res) (value (:value res)))
(when (:out res) (out (:out res)))
(when (:err res) (err (:err res)))
(when (:ns res) (reset! ns (:ns res))))
(recur)))))
(def #^{:private true} unary-options #{"--interactive" "--color"})
(defn- split-args
[args]
(loop [[arg & rem-args :as args] args
options {}]
(if-not (and arg (re-matches #"--.*" arg))
[options args]
(if (unary-options arg)
(recur rem-args
(assoc options arg true))
(recur (rest rem-args)
(assoc options arg (first rem-args)))))))
(defn -main
[& args]
(let [[options args] (split-args args)
server (start-server :port (Integer/parseInt (or (options "--port") "0")))
^java.net.ServerSocket ssocket (:ss @server)]
(when-let [ack-port (options "--ack")]
(binding [*out* *err*]
(println (format "ack'ing my port %d to other server running on port %s"
(.getLocalPort ssocket) ack-port)
(:status (send-ack (.getLocalPort ssocket) (Integer/parseInt ack-port))))))
(if (options "--interactive")
(run-repl (.getLocalPort ssocket) (when (options "--color") colored-output))
; need to hold process open with a non-daemon thread -- this should end up being super-temporary
(Thread/sleep Long/MAX_VALUE))))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/helpers.clj 0000664 0000000 0000000 00000004417 13070463361 0027577 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey. All rights reserved.
; The use and distribution terms for this software are covered by the
; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
; which can be found in the file epl-v10.html at the root of this distribution.
; By using this software in any fashion, you are agreeing to be bound by
; the terms of this license.
; You must not remove this notice, or any other, from this software.
(ns ^{:author "Chas Emerick"}
clojure.tools.nrepl.helpers
(:require [clojure.tools.nrepl.middleware.load-file :as load-file])
(:import (java.io File StringReader)))
(defn load-file-command
"(If it is available, sending clojure.tools.nrepl.middleware.load-file
compatible messages is far preferable.)
Returns a string expression that can be sent to an nREPL session to
load the Clojure code in given local file in the remote REPL's environment,
preserving debug information (e.g. line numbers, etc).
Typical usage: (nrepl-client-fn
{:op \"eval\" :code
(load-file-command \"/path/to/clojure/file.clj\")})
If appropriate, the source path from which the code is being loaded may
be provided as well (suitably trimming the file's path to a relative one
when loaded).
The 3-arg variation of this function expects the full source of the file to be loaded,
the source-root-relative path of the source file, and the name of the file. e.g.:
(load-file-command \"…code here…\" \"some/ns/name/file.clj\" \"file.clj\")"
([f] (load-file-command f nil))
([f source-root]
(let [^String abspath (if (string? f) f (.getAbsolutePath ^File f))
source-root (cond
(nil? source-root) ""
(string? source-root) source-root
(instance? File source-root) (.getAbsolutePath ^File source-root))]
(load-file-command (slurp abspath :encoding "UTF-8")
(if (and (seq source-root)
(.startsWith abspath source-root))
(-> abspath
(.substring (count source-root))
(.replaceAll "^[/\\\\]" ""))
abspath)
(-> abspath File. .getName))))
([code file-path file-name]
(load-file/load-file-code code file-path file-name))) tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware.clj 0000664 0000000 0000000 00000023744 13070463361 0030256 0 ustar 00root root 0000000 0000000 (ns clojure.tools.nrepl.middleware
(:require clojure.tools.nrepl
[clojure.tools.nrepl.transport :as transport]
[clojure.tools.nrepl.misc :as misc]
[clojure.set :as set])
(:refer-clojure :exclude (comparator ex-info)))
;; so much backport
(def ^:private ex-info
(or (resolve 'clojure.core/ex-info)
(fn [^String msg data]
(proxy [Exception clojure.lang.IDeref] [msg]
(deref [] data)))))
(defn- var-name
[^clojure.lang.Var v]
(str (.ns v) \/ (.sym v)))
(defn- wrap-conj-descriptor
[descriptor-map h]
(fn [{:keys [op descriptors] :as msg}]
(h (if-not (= op "describe")
msg
(assoc msg :descriptors (merge descriptor-map descriptors))))))
(defn set-descriptor!
"Sets the given [descriptor] map as the ::descriptor metadata on
the provided [middleware-var], after assoc'ing in the var's
fully-qualified name as the descriptor's \"implemented-by\" value."
[middleware-var descriptor]
(let [descriptor (-> descriptor
(assoc :implemented-by (-> middleware-var var-name symbol))
(update-in [:expects] (fnil conj #{}) "describe"))]
(alter-meta! middleware-var assoc ::descriptor descriptor)
(alter-var-root middleware-var #(comp (partial wrap-conj-descriptor
{middleware-var descriptor}) %))))
(defn- safe-version
[m]
(into {} (filter (fn [[_ v]] (or (number? v) (string? v))) m)))
(defn- java-version
[]
(let [version-string (System/getProperty "java.version")
version-seq (re-seq #"\d+" version-string)
version-map (if (<= 3 (count version-seq))
(zipmap [:major :minor :incremental :update] version-seq)
{})]
(assoc version-map :version-string version-string)))
(defn wrap-describe
[h]
(fn [{:keys [op descriptors verbose? transport] :as msg}]
(if (= op "describe")
(transport/send transport (misc/response-for msg
(merge
(when-let [aux (reduce
(fn [aux {:keys [describe-fn]}]
(if describe-fn
(merge aux (describe-fn msg))
aux))
nil
(vals descriptors))]
{:aux aux})
{:ops (let [ops (apply merge (map :handles (vals descriptors)))]
(if verbose?
ops
(zipmap (keys ops) (repeat {}))))
:versions {:nrepl (safe-version clojure.tools.nrepl/version)
:clojure (safe-version
(assoc *clojure-version* :version-string (clojure-version)))
:java (safe-version (java-version))}
:status :done})))
(h msg))))
(set-descriptor! #'wrap-describe
{:handles {"describe"
{:doc "Produce a machine- and human-readable directory and documentation for the operations supported by an nREPL endpoint."
:requires {}
:optional {"verbose?" "Include informational detail for each \"op\"eration in the return message."}
:returns {"ops" "Map of \"op\"erations supported by this nREPL endpoint"
"versions" "Map containing version maps (like *clojure-version*, e.g. major, minor, incremental, and qualifier keys) for values, component names as keys. Common keys include \"nrepl\" and \"clojure\"."
"aux" "Map of auxilliary data contributed by all of the active nREPL middleware via :describe-fn functions in their descriptors."}}}})
; eliminate implicit expectation of "describe" handler; this is the only
; special case introduced by the conj'ing of :expects "describe" by set-descriptor!
(alter-meta! #'wrap-describe update-in [::descriptor :expects] disj "describe")
(defn- dependencies
[set start dir]
(let [ops (start dir)
deps (set/select
(comp seq (partial set/intersection ops) :handles)
set)]
(when (deps start)
(throw (IllegalArgumentException.
(format "Middleware %s depends upon itself via %s"
(:implemented-by start)
dir))))
(concat ops
(mapcat #(dependencies set % dir) deps))))
(defn- comparator
[{a-requires :requires a-expects :expects a-handles :handles}
{b-requires :requires b-expects :expects b-handles :handles}]
(or (->> (into {} [[[a-requires b-handles] -1]
[[a-expects b-handles] 1]
[[b-requires a-handles] 1]
[[b-expects a-handles] -1]])
(map (fn [[sets ret]]
(and (seq (apply set/intersection sets)) ret)))
(some #{-1 1}))
0))
(defn- extend-deps
[middlewares]
(let [descriptor #(-> % meta ::descriptor)
middlewares (concat middlewares
(->> (map descriptor middlewares)
(mapcat (juxt :expects :requires))
(mapcat identity)
(filter var?)))]
(doseq [m (remove descriptor middlewares)]
(binding [*out* *err*]
(printf "[WARNING] No nREPL middleware descriptor in metadata of %s, see clojure.tools.middleware/set-descriptor!" m)
(println)))
(let [middlewares (set (for [m middlewares]
(-> (descriptor m)
; only conj'ing m here to support direct reference to
; middleware dependencies in :expects and :requires,
; e.g. interruptable-eval's dep on
; clojure.tools.nrepl.middleware.pr-values/pr-values
(update-in [:handles] (comp set #(conj % m) keys))
(assoc :implemented-by m))))]
(set (for [m middlewares]
(reduce
#(update-in % [%2] into (dependencies middlewares % %2))
m #{:expects :requires}))))))
(defn- topologically-sort
"Topologically sorts the given middlewares according to the comparator,
with the added huristic that any middlewares that have no dependencies
will be sorted toward the end."
[comparator stack]
(let [stack (vec stack)
;; using indexes into the above vector as the vertices in the
;; graph algorithm, will translate back into middlewares at
;; the end.
vertices (range (count stack))
edges (for [i1 vertices
i2 (range i1)
:let [x (comparator (stack i1) (stack i2))]
:when (not= 0 x)]
(if (neg? x) [i1 i2] [i2 i1]))
;; the trivial vertices have no connections, and we pull them
;; out here so we can make sure they get put on the end
trivial-vertices (remove (set (apply concat edges)) vertices)]
(loop [sorted-vertices []
remaining-edges edges
remaining-vertices (remove (set trivial-vertices) vertices)]
(if (seq remaining-vertices)
(let [non-initials (->> remaining-edges
(map second)
(set))
next-vertex (->> remaining-vertices
(remove non-initials)
(first))]
(if next-vertex
(recur (conj sorted-vertices next-vertex)
(remove #((set %) next-vertex) remaining-edges)
(remove #{next-vertex} remaining-vertices))
;; Cycle detected! Have to actually assemble a cycle so we
;; can throw a useful error.
(let [start (first remaining-vertices)
step (into {} remaining-edges)
cycle (->> (iterate step start)
(rest)
(take-while (complement #{start}))
(cons start))
data {:cycle (map stack cycle)}]
(throw (ex-info
"Unable to satisfy nrepl middleware ordering requirements!"
data)))))
(map stack (concat sorted-vertices trivial-vertices))))))
(defn linearize-middleware-stack
[middlewares]
(->> middlewares
extend-deps
(topologically-sort comparator)
(map :implemented-by)))
;;; documentation utilities ;;;
; oh, kill me now
(defn- markdown-escape
[^String s]
(.replaceAll s "([*_])" "\\\\$1"))
(defn- message-slot-markdown
[msg-slot-docs]
(apply str (for [[k v] msg-slot-docs]
(format "* `%s` %s\n" (pr-str k) (markdown-escape v)))))
(defn- describe-markdown
"Given a message containing the response to a verbose :describe message,
generates a markdown string conveying the information therein, suitable for
use in e.g. wiki pages, github, etc.
(This is currently private because markdown conversion surely shouldn't
be part of the API here...?)"
[{:keys [ops versions]}]
(apply str "# Supported nREPL operations
generated from a verbose 'describe' response (nREPL v"
(:version-string clojure.tools.nrepl/version)
")\n\n## Operations"
(for [[op {:keys [doc optional requires returns]}] ops]
(str "\n\n### `" (pr-str op) "`\n\n"
(markdown-escape doc) "\n\n"
"###### Required parameters\n\n"
(message-slot-markdown requires)
"\n\n###### Optional parameters\n\n"
(message-slot-markdown optional)
"\n\n###### Returns\n\n"
(message-slot-markdown returns)))))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware/ 0000775 0000000 0000000 00000000000 13070463361 0027552 5 ustar 00root root 0000000 0000000 interruptible_eval.clj 0000664 0000000 0000000 00000031440 13070463361 0034066 0 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware (ns ^{:author "Chas Emerick"}
clojure.tools.nrepl.middleware.interruptible-eval
(:require [clojure.tools.nrepl.transport :as t]
clojure.tools.nrepl.middleware.pr-values
clojure.main)
(:use [clojure.tools.nrepl.misc :only (response-for returning)]
[clojure.tools.nrepl.middleware :only (set-descriptor!)])
(:import clojure.lang.LineNumberingPushbackReader
(java.io FilterReader LineNumberReader StringReader Writer)
java.lang.reflect.Field
java.util.concurrent.atomic.AtomicLong
(java.util.concurrent Executor BlockingQueue LinkedBlockingQueue ThreadFactory
SynchronousQueue TimeUnit ThreadPoolExecutor)))
(def ^:private reader-conditionals? (boolean (resolve 'clojure.core/reader-conditional)))
(def ^{:dynamic true
:doc "The message currently being evaluated."}
*msg* nil)
(def ^{:dynamic true
:doc "Function returning the evaluation of its argument."}
*eval* nil)
(defn- capture-thread-bindings
"Capture thread bindings, excluding nrepl implementation vars."
[]
(dissoc (get-thread-bindings) #'*msg* #'*eval*))
(defn- set-line!
[^LineNumberingPushbackReader reader line]
(-> FilterReader
^Field (.getDeclaredField "in")
(doto (.setAccessible true))
^LineNumberReader (.get reader)
(.setLineNumber line)))
(defn- set-column!
[^LineNumberingPushbackReader reader column]
(when-let [field (->> LineNumberingPushbackReader
(.getDeclaredFields)
(filter #(= "_columnNumber" (.getName ^Field %)))
first)]
(-> ^Field field
(doto (.setAccessible true))
(.set reader column))))
(defn- source-logging-pushback-reader
[code line column]
(let [reader (LineNumberingPushbackReader. (StringReader. code))]
(when line (set-line! reader (int (dec line))))
(when column (set-column! reader (int column)))
reader))
(defn evaluate
"Evaluates some code within the dynamic context defined by a map of `bindings`,
as per `clojure.core/get-thread-bindings`.
Uses `clojure.main/repl` to drive the evaluation of :code in a second
map argument (either a string or a seq of forms to be evaluated), which may
also optionally specify a :ns (resolved via `find-ns`). The map MUST
contain a Transport implementation in :transport; expression results and errors
will be sent via that Transport.
Returns the dynamic scope that remains after evaluating all expressions
in :code.
It is assumed that `bindings` already contains useful/appropriate entries
for all vars indicated by `clojure.main/with-bindings`."
[bindings {:keys [code ns transport session eval file line column] :as msg}]
(let [explicit-ns-binding (when-let [ns (and ns (-> ns symbol find-ns))]
{#'*ns* ns})
original-ns (bindings #'*ns*)
maybe-restore-original-ns (fn [bindings]
(if-not explicit-ns-binding
bindings
(assoc bindings #'*ns* original-ns)))
file (or file (get bindings #'*file*))
bindings (atom (merge bindings explicit-ns-binding {#'*file* file}))
session (or session (atom nil))
out (@bindings #'*out*)
err (@bindings #'*err*)]
(if (and ns (not explicit-ns-binding))
(t/send transport (response-for msg {:status #{:error :namespace-not-found :done}}))
(with-bindings @bindings
(try
(clojure.main/repl
:eval (if eval (find-var (symbol eval)) clojure.core/eval)
;; clojure.main/repl paves over certain vars even if they're already thread-bound
:init #(do (set! *compile-path* (@bindings #'*compile-path*))
(set! *1 (@bindings #'*1))
(set! *2 (@bindings #'*2))
(set! *3 (@bindings #'*3))
(set! *e (@bindings #'*e)))
:read (if (string? code)
(let [reader (source-logging-pushback-reader code line column)]
(if reader-conditionals?
#(read {:read-cond :allow :eof %2} reader)
#(read reader false %2)))
(let [code (.iterator ^Iterable code)]
#(or (and (.hasNext code) (.next code)) %2)))
:prompt (fn [])
:need-prompt (constantly false)
; TODO pretty-print?
:print (fn [v]
(reset! bindings (assoc (capture-thread-bindings)
#'*3 *2
#'*2 *1
#'*1 v))
(.flush ^Writer err)
(.flush ^Writer out)
(reset! session (maybe-restore-original-ns @bindings))
(t/send transport (response-for msg
{:value v
:ns (-> *ns* ns-name str)})))
; TODO customizable exception prints
:caught (fn [e]
(let [root-ex (#'clojure.main/root-cause e)]
(when-not (instance? ThreadDeath root-ex)
(reset! bindings (assoc (capture-thread-bindings) #'*e e))
(reset! session (maybe-restore-original-ns @bindings))
(t/send transport (response-for msg {:status :eval-error
:ex (-> e class str)
:root-ex (-> root-ex class str)}))
(clojure.main/repl-caught e)))))
(finally
(.flush ^Writer out)
(.flush ^Writer err)))))
(maybe-restore-original-ns @bindings)))
(defn- configure-thread-factory
"Returns a new ThreadFactory for the given session. This implementation
generates daemon threads, with names that include the session id."
[]
(let [session-thread-counter (AtomicLong. 0)]
(reify ThreadFactory
(newThread [_ runnable]
(doto (Thread. runnable
(format "nREPL-worker-%s" (.getAndIncrement session-thread-counter)))
(.setDaemon true))))))
(def ^{:private true} jdk6? (try
(Class/forName "java.util.ServiceLoader")
true
(catch ClassNotFoundException e false)))
; this is essentially the same as Executors.newCachedThreadPool, except
; for the JDK 5/6 fix described below
(defn- configure-executor
"Returns a ThreadPoolExecutor, configured (by default) to
have no core threads, use an unbounded queue, create only daemon threads,
and allow unused threads to expire after 30s."
[& {:keys [keep-alive queue thread-factory]
:or {keep-alive 30000
queue (SynchronousQueue.)}}]
(let [^ThreadFactory thread-factory (or thread-factory (configure-thread-factory))]
; ThreadPoolExecutor in JDK5 *will not run* submitted jobs if the core pool size is zero and
; the queue has not yet rejected a job (see http://kirkwylie.blogspot.com/2008/10/java5-vs-java6-threadpoolexecutor.html)
(ThreadPoolExecutor. (if jdk6? 0 1) Integer/MAX_VALUE
(long 30000) TimeUnit/MILLISECONDS
^BlockingQueue queue
thread-factory)))
(def default-executor (delay (configure-executor)))
; A little mini-agent implementation. Needed because agents cannot be used to host REPL
; evaluation: http://dev.clojure.org/jira/browse/NREPL-17
(defn- prep-session
[session]
(locking session
(returning session
(when-not (-> session meta :queue)
(alter-meta! session assoc :queue (atom clojure.lang.PersistentQueue/EMPTY))))))
(declare run-next)
(defn- run-next*
[session ^Executor executor]
(let [qa (-> session meta :queue)]
(loop []
(let [q @qa
qn (pop q)]
(if-not (compare-and-set! qa q qn)
(recur)
(when (seq qn)
(.execute executor (run-next session executor (peek qn)))))))))
(defn- run-next
[session executor f]
#(try
(f)
(finally
(run-next* session executor))))
(defn queue-eval
"Queues the function for the given session."
[session ^Executor executor f]
(let [qa (-> session prep-session meta :queue)]
(loop []
(let [q @qa]
(if-not (compare-and-set! qa q (conj q f))
(recur)
(when (empty? q)
(.execute executor (run-next session executor f))))))))
(defn interruptible-eval
"Evaluation middleware that supports interrupts. Returns a handler that supports
\"eval\" and \"interrupt\" :op-erations that delegates to the given handler
otherwise."
[h & configuration]
(let [executor (:executor configuration @default-executor)]
(fn [{:keys [op session interrupt-id id transport] :as msg}]
(case op
"eval"
(if-not (:code msg)
(t/send transport (response-for msg :status #{:error :no-code}))
(queue-eval session executor
(fn []
(alter-meta! session assoc
:thread (Thread/currentThread)
:eval-msg msg)
(binding [*msg* msg]
(evaluate @session msg)
(t/send transport (response-for msg :status :done))
(alter-meta! session dissoc :thread :eval-msg)))))
"interrupt"
; interrupts are inherently racy; we'll check the agent's :eval-msg's :id and
; bail if it's different than the one provided, but it's possible for
; that message's eval to finish and another to start before we send
; the interrupt / .stop.
(let [{:keys [id eval-msg ^Thread thread]} (meta session)]
(if (or (not interrupt-id)
(= interrupt-id (:id eval-msg)))
(if-not thread
(t/send transport (response-for msg :status #{:done :session-idle}))
(do
; notify of the interrupted status before we .stop the thread so
; it is received before the standard :done status (thereby ensuring
; that is stays within the scope of a clojure.tools.nrepl/message seq
(t/send transport {:status #{:interrupted}
:id (:id eval-msg)
:session id})
(.stop thread)
(t/send transport (response-for msg :status #{:done}))))
(t/send transport (response-for msg :status #{:error :interrupt-id-mismatch :done}))))
(h msg)))))
(set-descriptor! #'interruptible-eval
{:requires #{"clone" "close" #'clojure.tools.nrepl.middleware.pr-values/pr-values}
:expects #{}
:handles {"eval"
{:doc "Evaluates code."
:requires {"code" "The code to be evaluated."
"session" "The ID of the session within which to evaluate the code."}
:optional {"id" "An opaque message ID that will be included in responses related to the evaluation, and which may be used to restrict the scope of a later \"interrupt\" operation."
"eval" "A fully-qualified symbol naming a var whose function value will be used to evaluate [code], instead of `clojure.core/eval` (the default)."
"file" "The path to the file containing [code]. `clojure.core/*file*` will be bound to this."
"line" "The line number in [file] at which [code] starts."
"column" "The column number in [file] at which [code] starts."}
:returns {"ns" "*ns*, after successful evaluation of `code`."
"values" "The result of evaluating `code`, often `read`able. This printing is provided by the `pr-values` middleware, and could theoretically be customized. Superseded by `ex` and `root-ex` if an exception occurs during evaluation."
"ex" "The type of exception thrown, if any. If present, then `values` will be absent."
"root-ex" "The type of the root exception thrown, if any. If present, then `values` will be absent."}}
"interrupt"
{:doc "Attempts to interrupt some code evaluation."
:requires {"session" "The ID of the session used to start the evaluation to be interrupted."}
:optional {"interrupt-id" "The opaque message ID sent with the original \"eval\" request."}
:returns {"status" "'interrupted' if an evaluation was identified and interruption will be attempted
'session-idle' if the session is not currently evaluating any code
'interrupt-id-mismatch' if the session is currently evaluating code sent using a different ID than specified by the \"interrupt-id\" value "}}}})
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware/load_file.clj 0000664 0000000 0000000 00000011621 13070463361 0032163 0 ustar 00root root 0000000 0000000 (ns ^{:author "Chas Emerick"}
clojure.tools.nrepl.middleware.load-file
(:require [clojure.tools.nrepl.middleware.interruptible-eval :as eval]
[clojure.tools.nrepl.transport :as t])
(:import clojure.tools.nrepl.transport.Transport)
(:use [clojure.tools.nrepl.middleware :as middleware :only (set-descriptor!)]))
; need to hold file contents "out of band" so as to avoid JVM method
; size limitations (cannot eval an expression larger than some size
; [64k?]), so the naive approach of just interpolating file contents
; into an expression to be evaluated doesn't work
; see http://code.google.com/p/counterclockwise/issues/detail?id=429
; and http://groups.google.com/group/clojure/browse_thread/thread/f54044da06b9939f
(defonce ^{:private true
:doc "An atom that temporarily holds the contents of files to
be loaded."} file-contents (atom {}))
(defn- load-large-file-code
"A variant of `load-file-code` that returns an
expression that will only work if evaluated within the same process
where it was called. Here to work around the JVM method size limit
so that (by default, for those tools using the load-file middleware)
loading files of any size will work when the nREPL server is running
remotely or locally."
[file file-path file-name]
; mini TTL impl so that any code orphaned by errors that occur
; between here and the evaluation of the Compiler/load expression
; below are cleaned up on subsequent loads
(let [t (System/currentTimeMillis)
file-key ^{:t t} [file-path (gensym)]]
(swap! file-contents
(fn [file-contents]
(let [expired-keys
(filter
(comp #(and %
(< 10000 (- (System/currentTimeMillis) %)))
:t meta)
(keys file-contents))]
(assoc (apply dissoc file-contents expired-keys)
file-key file))))
(binding [*print-length* nil
*print-level* nil]
(pr-str `(try
(clojure.lang.Compiler/load
(java.io.StringReader. (@@(var file-contents) '~file-key))
~file-path
~file-name)
(finally
(swap! @(var file-contents) dissoc '~file-key)))))))
(defn ^{:dynamic true} load-file-code
"Given the contents of a file, its _source-path-relative_ path,
and its filename, returns a string of code containing a single
expression that, when evaluated, will load those contents with
appropriate filename references and line numbers in metadata, etc.
Note that because a single expression is produced, very large
file loads will fail due to the JVM method size limitation.
In such cases, see `load-large-file-code'`."
[file file-path file-name]
(apply format
"(clojure.lang.Compiler/load (java.io.StringReader. %s) %s %s)"
(map (fn [item]
(binding [*print-length* nil
*print-level* nil]
(pr-str item)))
[file file-path file-name])))
(defn wrap-load-file
"Middleware that evaluates a file's contents, as per load-file,
but with all data supplied in the sent message (i.e. safe for use
with remote REPL environments).
This middleware depends on the availability of an :op \"eval\"
middleware below it (such as interruptible-eval)."
[h]
(fn [{:keys [op file file-name file-path transport] :as msg}]
(if (not= op "load-file")
(h msg)
(h (assoc (dissoc msg :file :file-name :file-path)
:op "eval"
:code ((if (thread-bound? #'load-file-code)
load-file-code
load-large-file-code)
file file-path file-name)
:transport (reify Transport
(recv [this] (.recv transport))
(recv [this timeout] (.recv transport timeout))
(send [this resp]
; *ns* is always 'user' after loading a file, so
; *remove it to avoid confusing tools that assume any
; *:ns always reports *ns*
(.send transport (dissoc resp :ns))
this)))))))
(set-descriptor! #'wrap-load-file
{:requires #{}
:expects #{"eval"}
:handles {"load-file"
{:doc "Loads a body of code, using supplied path and filename info to set source file and line number metadata. Delegates to underlying \"eval\" middleware/handler."
:requires {"file" "Full contents of a file of code."}
:optional {"file-path" "Source-path-relative path of the source file, e.g. clojure/java/io.clj"
"file-name" "Name of source file, e.g. io.clj"}
:returns (-> (meta #'eval/interruptible-eval)
::middleware/descriptor
:handles
(get "eval")
:returns)}}})
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware/pr_values.clj 0000664 0000000 0000000 00000003522 13070463361 0032246 0 ustar 00root root 0000000 0000000
(ns ^{:author "Chas Emerick"}
clojure.tools.nrepl.middleware.pr-values
(:require [clojure.tools.nrepl.transport :as t])
(:use [clojure.tools.nrepl.middleware :only (set-descriptor!)])
(:import clojure.tools.nrepl.transport.Transport))
(defn pr-values
"Middleware that returns a handler which transforms any :value slots
in messages sent via the request's Transport to strings via `pr`,
delegating all actual message handling to the provided handler.
Requires that results of eval operations are sent in messages in a
:value slot.
If :value is already a string, and a sent message's :printed-value
slot contains any truthy value, then :value will not be re-printed.
This allows evaluation contexts to produce printed results in :value
if they so choose, and opt out of the printing here."
[h]
(fn [{:keys [op ^Transport transport] :as msg}]
(h (assoc msg
:transport (reify Transport
(recv [this] (.recv transport))
(recv [this timeout] (.recv transport timeout))
(send [this {:keys [printed-value value] :as resp}]
(.send transport
(if (and printed-value (string? value))
(dissoc resp :printed-value)
(if-let [[_ v] (find resp :value)]
(assoc resp
:value (let [repr (java.io.StringWriter.)]
(if *print-dup*
(print-dup v repr)
(print-method v repr))
(str repr)))
resp)))
this))))))
(set-descriptor! #'pr-values
{:requires #{}
:expects #{}
:handles {}})
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/middleware/session.clj 0000664 0000000 0000000 00000027210 13070463361 0031731 0 ustar 00root root 0000000 0000000
(ns ^{:doc "Support for persistent, cross-connection REPL sessions."
:author "Chas Emerick"}
clojure.tools.nrepl.middleware.session
(:use [clojure.tools.nrepl.misc :only (uuid response-for returning log)]
[clojure.tools.nrepl.middleware.interruptible-eval :only (*msg*)]
[clojure.tools.nrepl.middleware :only (set-descriptor!)])
(:require (clojure main test)
[clojure.tools.nrepl.transport :as t])
(:import clojure.tools.nrepl.transport.Transport
(java.io PipedReader PipedWriter Reader Writer PrintWriter StringReader)
clojure.lang.LineNumberingPushbackReader
java.util.concurrent.LinkedBlockingQueue))
(def ^{:private true} sessions (atom {}))
;; TODO the way this is currently, :out and :err will continue to be
;; associated with a particular *msg* (and session) even when produced from a future,
;; agent, etc. due to binding conveyance. This may or may not be desirable
;; depending upon the expectations of the client/user. I'm not sure at the moment
;; how best to make it configurable though...
(def ^{:dynamic true :private true} *out-limit* 1024)
(def ^{:dynamic true :private true} *skipping-eol* false)
(defn- session-out
"Returns a PrintWriter suitable for binding as *out* or *err*. All of
the content written to that PrintWriter will (when .flush-ed) be sent on the
given transport in messages specifying the given session-id.
`channel-type` should be :out or :err, as appropriate."
[channel-type session-id transport]
(let [buf (clojure.tools.nrepl.StdOutBuffer.)]
(PrintWriter. (proxy [Writer] []
(close [] (.flush ^Writer this))
(write [& [x ^Integer off ^Integer len]]
(locking buf
(cond
(number? x) (.append buf (char x))
(not off) (.append buf x)
; the CharSequence overload of append takes an *end* idx, not length!
(instance? CharSequence x) (.append buf ^CharSequence x (int off) (int (+ len off)))
:else (.append buf ^chars x off len))
(when (<= *out-limit* (.length buf))
(.flush ^Writer this))))
(flush []
(let [text (locking buf (let [text (str buf)]
(.setLength buf 0)
text))]
(when (pos? (count text))
(t/send (or (:transport *msg*) transport)
(response-for *msg* :session session-id
channel-type text))))))
true)))
(defn- session-in
"Returns a LineNumberingPushbackReader suitable for binding to *in*.
When something attempts to read from it, it will (if empty) send a
{:status :need-input} message on the provided transport so the client/user
can provide content to be read."
[session-id transport]
(let [input-queue (LinkedBlockingQueue.)
request-input (fn []
(cond (> (.size input-queue) 0)
(.take input-queue)
*skipping-eol*
nil
:else
(do
(t/send transport
(response-for *msg* :session session-id
:status :need-input))
(.take input-queue))))
do-read (fn [buf off len]
(locking input-queue
(loop [i off]
(cond
(>= i (+ off len))
(+ off len)
(.peek input-queue)
(do (aset-char buf i (char (.take input-queue)))
(recur (inc i)))
:else
i))))
reader (LineNumberingPushbackReader.
(proxy [Reader] []
(close [] (.clear input-queue))
(read
([]
(let [^Reader this this] (proxy-super read)))
([x]
(let [^Reader this this]
(if (instance? java.nio.CharBuffer x)
(proxy-super read ^java.nio.CharBuffer x)
(proxy-super read ^chars x))))
([^chars buf off len]
(if (zero? len)
-1
(let [first-character (request-input)]
(if (or (nil? first-character) (= first-character -1))
-1
(do
(aset-char buf off (char first-character))
(- (do-read buf (inc off) (dec len))
off)))))))))]
{:input-queue input-queue
:stdin-reader reader}))
(defn- create-session
"Returns a new atom containing a map of bindings as per
`clojure.core/get-thread-bindings`. Values for *out*, *err*, and *in*
are obtained using `session-in` and `session-out`, *ns* defaults to 'user,
and other bindings as optionally provided in `baseline-bindings` are
merged in."
([transport] (create-session transport {}))
([transport baseline-bindings]
(clojure.main/with-bindings
(let [id (uuid)
out (session-out :out id transport)
{:keys [input-queue stdin-reader]} (session-in id transport)]
(binding [*out* out
*err* (session-out :err id transport)
*in* stdin-reader
*ns* (create-ns 'user)
*out-limit* (or (baseline-bindings #'*out-limit*) 1024)
; clojure.test captures *out* at load-time, so we need to make sure
; runtime output of test status/results is redirected properly
; TODO is this something we need to consider in general, or is this
; specific hack reasonable?
clojure.test/*test-out* out]
; nrepl.server happens to use agents for connection dispatch
; don't capture that *agent* binding for userland REPL sessions
(atom (merge baseline-bindings (dissoc (get-thread-bindings) #'*agent*))
:meta {:id id
:stdin-reader stdin-reader
:input-queue input-queue}))))))
(defn- register-session
"Registers a new session containing the baseline bindings contained in the
given message's :session."
[{:keys [session transport] :as msg}]
(let [session (create-session transport @session)
id (-> session meta :id)]
(swap! sessions assoc id session)
(t/send transport (response-for msg :status :done :new-session id))))
(defn- close-session
"Drops the session associated with the given message."
[{:keys [session transport] :as msg}]
(swap! sessions dissoc (-> session meta :id))
(t/send transport (response-for msg :status #{:done :session-closed})))
(defn session
"Session middleware. Returns a handler which supports these :op-erations:
* \"ls-sessions\", which results in a response message
containing a list of the IDs of the currently-retained sessions in a
:session slot.
* \"close\", which drops the session indicated by the
ID in the :session slot. The response message's :status will include
:session-closed.
* \"clone\", which will cause a new session to be retained. The ID of this
new session will be returned in a response message in a :new-session
slot. The new session's state (dynamic scope, etc) will be a copy of
the state of the session identified in the :session slot of the request.
Messages indicating other operations are delegated to the given handler,
with the session identified by the :session ID added to the message. If
no :session ID is found, a new session is created (which will only
persist for the duration of the handling of the given message).
Requires the interruptible-eval middleware (specifically, its binding of
*msg* to the currently-evaluated message so that session-specific *out*
and *err* content can be associated with the originating message)."
[h]
(fn [{:keys [op session transport out-limit] :as msg}]
(let [the-session (if session
(@sessions session)
(create-session transport))]
(if-not the-session
(t/send transport (response-for msg :status #{:error :unknown-session}))
(let [msg (assoc msg :session the-session)]
;; TODO yak, this is ugly; need to cleanly thread out-limit through to
;; session-out without abusing a dynamic var
;; (there's no reason to allow a connected client to fark around with
;; a session-out's "buffer")
(when out-limit (swap! the-session assoc #'*out-limit* out-limit))
(case op
"clone" (register-session msg)
"close" (close-session msg)
"ls-sessions" (t/send transport (response-for msg :status :done
:sessions (or (keys @sessions) [])))
(h msg)))))))
(set-descriptor! #'session
{:requires #{}
:expects #{}
:describe-fn (fn [{:keys [session] :as describe-msg}]
(when (and session (instance? clojure.lang.Atom session))
{:current-ns (-> @session (get #'*ns*) str)}))
:handles {"close"
{:doc "Closes the specified session."
:requires {"session" "The ID of the session to be closed."}
:optional {}
:returns {}}
"ls-sessions"
{:doc "Lists the IDs of all active sessions."
:requires {}
:optional {}
:returns {"sessions" "A list of all available session IDs."}}
"clone"
{:doc "Clones the current session, returning the ID of the newly-created session."
:requires {}
:optional {"session" "The ID of the session to be cloned; if not provided, a new session with default bindings is created, and mapped to the returned session ID."}
:returns {"new-session" "The ID of the new session."}}}})
(defn add-stdin
"stdin middleware. Returns a handler that supports a \"stdin\" :op-eration, which
adds content provided in a :stdin slot to the session's *in* Reader. Delegates to
the given handler for other operations.
Requires the session middleware."
[h]
(fn [{:keys [op stdin session transport] :as msg}]
(cond
(= op "eval")
(let [in (-> (meta session) ^LineNumberingPushbackReader (:stdin-reader))]
(binding [*skipping-eol* true]
(clojure.main/skip-if-eol in))
(h msg))
(= op "stdin")
(let [q (-> (meta session) ^LinkedBlockingQueue (:input-queue))]
(if (empty? stdin)
(.put q -1)
(locking q
(doseq [c stdin] (.put q c))))
(t/send transport (response-for msg :status :done)))
:else
(h msg))))
(set-descriptor! #'add-stdin
{:requires #{#'session}
:expects #{"eval"}
:handles {"stdin"
{:doc "Add content from the value of \"stdin\" to *in* in the current session."
:requires {"stdin" "Content to add to *in*."}
:optional {}
:returns {"status" "A status of \"need-input\" will be sent if a session's *in* requires content in order to satisfy an attempted read operation."}}}})
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/misc.clj 0000664 0000000 0000000 00000004270 13070463361 0027065 0 ustar 00root root 0000000 0000000 (ns ^{:doc "Misc utilities used in nREPL's implementation (potentially also useful
for anyone extending it)."
:author "Chas Emerick"}
clojure.tools.nrepl.misc)
(try
(require 'clojure.tools.logging)
(defmacro log [& args] `(clojure.tools.logging/error ~@args))
(catch Throwable t
;(println "clojure.tools.logging not available, falling back to stdout/err")
(defn log
[ex & msgs]
(let [ex (when (instance? Throwable ex) ex)
msgs (if ex msgs (cons ex msgs))]
(binding [*out* *err*]
(apply println "ERROR:" msgs)
(when ex (.printStackTrace ^Throwable ex)))))))
(defmacro returning
"Executes `body`, returning `x`."
[x & body]
`(let [x# ~x] ~@body x#))
(defn uuid
"Returns a new UUID string."
[]
(str (java.util.UUID/randomUUID)))
(defn response-for
"Returns a map containing the :session and :id from the \"request\" `msg`
as well as all entries specified in `response-data`, which can be one
or more maps (which will be merged), *or* key-value pairs.
(response-for msg :status :done :value \"5\")
(response-for msg {:status :interrupted})
The :session value in `msg` may be any Clojure reference type (to accommodate
likely implementations of sessions) that has an :id slot in its metadata,
or a string."
[{:keys [session id]} & response-data]
{:pre [(seq response-data)]}
(let [{:keys [status] :as response} (if (map? (first response-data))
(reduce merge response-data)
(apply hash-map response-data))
response (if (not status)
response
(assoc response :status (if (coll? status)
status
#{status})))
basis (merge (when id {:id id})
; AReference should make this suitable for any session implementation?
(when session {:session (if (instance? clojure.lang.AReference session)
(-> session meta :id)
session)}))]
(merge basis response))) tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/server.clj 0000775 0000000 0000000 00000014707 13070463361 0027451 0 ustar 00root root 0000000 0000000 (ns ^{:doc "Default server implementations"
:author "Chas Emerick"}
clojure.tools.nrepl.server
(:require [clojure.tools.nrepl :as repl]
(clojure.tools.nrepl [ack :as ack]
[transport :as t]
[middleware :as middleware])
(clojure.tools.nrepl.middleware interruptible-eval
pr-values
session
load-file)
clojure.pprint)
(:use [clojure.tools.nrepl.misc :only (returning response-for log)])
(:import (java.net Socket ServerSocket InetSocketAddress InetAddress)))
(defn handle*
[msg handler transport]
(try
(handler (assoc msg :transport transport))
(catch Throwable t
(log t "Unhandled REPL handler exception processing message" msg))))
(defn handle
"Handles requests received via [transport] using [handler].
Returns nil when [recv] returns nil for the given transport."
[handler transport]
(when-let [msg (t/recv transport)]
(future (handle* msg handler transport))
(recur handler transport)))
(defn- safe-close
[^java.io.Closeable x]
(try
(.close x)
(catch java.io.IOException e
(log e "Failed to close " x))))
(defn- accept-connection
[{:keys [^ServerSocket server-socket open-transports transport greeting handler]
:as server}]
(when-not (.isClosed server-socket)
(let [sock (.accept server-socket)]
(future (let [transport (transport sock)]
(try
(swap! open-transports conj transport)
(when greeting (greeting transport))
(handle handler transport)
(finally
(swap! open-transports disj transport)
(safe-close transport)))))
(future (accept-connection server)))))
(defn stop-server
"Stops a server started via `start-server`."
[{:keys [open-transports ^ServerSocket server-socket] :as server}]
(returning server
(.close server-socket)
(swap! open-transports #(reduce
(fn [s t]
; should always be true for the socket server...
(if (instance? java.io.Closeable t)
(do
(safe-close t)
(disj s t))
s))
% %))))
(defn unknown-op
"Sends an :unknown-op :error for the given message."
[{:keys [op transport] :as msg}]
(t/send transport (response-for msg :status #{:error :unknown-op :done} :op op)))
(def default-middlewares
[#'clojure.tools.nrepl.middleware/wrap-describe
#'clojure.tools.nrepl.middleware.interruptible-eval/interruptible-eval
#'clojure.tools.nrepl.middleware.load-file/wrap-load-file
#'clojure.tools.nrepl.middleware.session/add-stdin
#'clojure.tools.nrepl.middleware.session/session])
(defn default-handler
"A default handler supporting interruptible evaluation, stdin, sessions, and
readable representations of evaluated expressions via `pr`.
Additional middlewares to mix into the default stack may be provided; these
should all be values (usually vars) that have an nREPL middleware descriptor
in their metadata (see clojure.tools.nrepl.middleware/set-descriptor!)."
[& additional-middlewares]
(let [stack (middleware/linearize-middleware-stack (concat default-middlewares
additional-middlewares))]
((apply comp (reverse stack)) unknown-op)))
;; TODO
#_(defn- output-subscriptions
[h]
(fn [{:keys [op sub unsub] :as msg}]
(case op
"sub" ;; TODO
"unsub"
(h msg))))
(defrecord Server [server-socket port open-transports transport greeting handler]
java.io.Closeable
(close [this] (stop-server this))
;; TODO here for backward compat with 0.2.x; drop for 0.3.0; this is what's
;; causing the print-method silliness below
clojure.lang.IDeref
(deref [this] this))
(#'clojure.pprint/use-method
clojure.pprint/simple-dispatch
Server
#'clojure.pprint/pprint-simple-default)
(try
; IRecord not available in 1.2.0
(eval '(defmethod print-method Server
[s w]
((get-method print-method clojure.lang.IRecord) s w)))
(catch Throwable _))
(defn start-server
"Starts a socket-based nREPL server. Configuration options include:
* :port — defaults to 0, which autoselects an open port
* :bind — bind address, by default \"::\" (falling back to \"localhost\"
if \"::\" isn't resolved by the underlying network stack)
* :handler — the nREPL message handler to use for each incoming connection;
defaults to the result of `(default-handler)`
* :transport-fn — a function that, given a java.net.Socket corresponding
to an incoming connection, will return an value satisfying the
clojure.tools.nrepl.Transport protocol for that Socket.
* :ack-port — if specified, the port of an already-running server
that will be connected to to inform of the new server's port.
Useful only by Clojure tooling implementations.
Returns a (map) handle to the server that is started, which may be stopped
either via `stop-server`, (.close server), or automatically via `with-open`.
The port that the server is open on is available in the :port slot of the
server map (useful if the :port option is 0 or was left unspecified."
[& {:keys [port bind transport-fn handler ack-port greeting-fn] :or {port 0}}]
(let [bind-addr (if bind
(InetSocketAddress. ^String bind ^Integer port)
(let [local (InetSocketAddress. "::" port)]
(if (.isUnresolved local)
(InetSocketAddress. "localhost" port)
local)))
ss (doto (ServerSocket.)
(.setReuseAddress true)
(.bind bind-addr))
server (assoc
(Server. ss
(.getLocalPort ss)
(atom #{})
(or transport-fn t/bencode)
greeting-fn
(or handler (default-handler)))
;; TODO here for backward compat with 0.2.x; drop eventually
:ss ss)]
(future (accept-connection server))
(when ack-port
(ack/send-ack (:port server) ack-port))
server))
tools.nrepl-tools.nrepl-0.2.13/src/main/clojure/clojure/tools/nrepl/transport.clj 0000664 0000000 0000000 00000014470 13070463361 0030171 0 ustar 00root root 0000000 0000000
(ns ^{:author "Chas Emerick"}
clojure.tools.nrepl.transport
(:require [clojure.tools.nrepl.bencode :as be]
[clojure.java.io :as io]
(clojure walk set))
(:use [clojure.tools.nrepl.misc :only (returning uuid)])
(:refer-clojure :exclude (send))
(:import (java.io InputStream OutputStream PushbackInputStream
PushbackReader IOException EOFException)
(java.net Socket SocketException)
(java.util.concurrent SynchronousQueue LinkedBlockingQueue
BlockingQueue TimeUnit)
clojure.lang.RT))
(defprotocol Transport
"Defines the interface for a wire protocol implementation for use
with nREPL."
(recv [this] [this timeout]
"Reads and returns the next message received. Will block.
Should return nil the a message is not available after `timeout`
ms or if the underlying channel has been closed.")
(send [this msg] "Sends msg. Implementations should return the transport."))
(deftype FnTransport [recv-fn send-fn close]
Transport
;; TODO this keywordization/stringification has no business being in FnTransport
(send [this msg] (-> msg clojure.walk/stringify-keys send-fn) this)
(recv [this] (.recv this Long/MAX_VALUE))
(recv [this timeout] (clojure.walk/keywordize-keys (recv-fn timeout)))
java.io.Closeable
(close [this] (close)))
(defn fn-transport
"Returns a Transport implementation that delegates its functionality
to the 2 or 3 functions provided."
([read write] (fn-transport read write nil))
([read write close]
(let [read-queue (SynchronousQueue.)
msg-pump (future (try
(while true
(.put read-queue (read)))
(catch Throwable t
(.put read-queue t))))]
(FnTransport.
(let [failure (atom nil)]
#(if @failure
(throw @failure)
(let [msg (.poll read-queue % TimeUnit/MILLISECONDS)]
(if (instance? Throwable msg)
(do (reset! failure msg) (throw msg))
msg))))
write
(fn [] (close) (future-cancel msg-pump))))))
(defmulti #^{:private true} > input
(map (fn [[k v]] [k ( ")))
session-id (atom nil)
read-msg #(let [code (read r)]
(merge {:op "eval" :code [code] :ns @cns :id (str "eval" (uuid))}
(when @session-id {:session @session-id})))
read-seq (atom (cons {:op "clone"} (repeatedly read-msg)))
write (fn [{:strs [out err value status ns new-session id] :as msg}]
(when new-session (reset! session-id new-session))
(when ns (reset! cns ns))
(doseq [^String x [out err value] :when x]
(.write w x))
(when (and (= status #{:done}) id (.startsWith ^String id "eval"))
(prompt true))
(.flush w))
read #(let [head (promise)]
(swap! read-seq (fn [s]
(deliver head (first s))
(rest s)))
@head)]
(fn-transport read write
(when s
(swap! read-seq (partial cons {:session @session-id :op "close"}))
#(.close s))))))
(defn tty-greeting
"A greeting fn usable with clojure.tools.nrepl.server/start-server,
meant to be used in conjunction with Transports returned by the
`tty` function.
Usually, Clojure-aware client-side tooling would provide this upon connecting
to the server, but telnet et al. isn't that."
[transport]
(send transport {:out (str ";; Clojure " (clojure-version)
\newline "user=> ")}))
(deftype QueueTransport [^BlockingQueue in ^BlockingQueue out]
clojure.tools.nrepl.transport.Transport
(send [this msg] (.put out msg) this)
(recv [this] (.take in))
(recv [this timeout] (.poll in timeout TimeUnit/MILLISECONDS)))
(defn piped-transports
"Returns a pair of Transports that read from and write to each other."
[]
(let [a (LinkedBlockingQueue.)
b (LinkedBlockingQueue.)]
[(QueueTransport. a b) (QueueTransport. b a)]))
tools.nrepl-tools.nrepl-0.2.13/src/main/java/ 0000775 0000000 0000000 00000000000 13070463361 0020770 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/java/clojure/ 0000775 0000000 0000000 00000000000 13070463361 0022433 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/java/clojure/tools/ 0000775 0000000 0000000 00000000000 13070463361 0023573 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/java/clojure/tools/nrepl/ 0000775 0000000 0000000 00000000000 13070463361 0024713 5 ustar 00root root 0000000 0000000 tools.nrepl-tools.nrepl-0.2.13/src/main/java/clojure/tools/nrepl/Connection.java 0000664 0000000 0000000 00000012027 13070463361 0027657 0 ustar 00root root 0000000 0000000 /**
* Copyright (c) Rich Hickey. All rights reserved.
* The use and distribution terms for this software are covered by the
* Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
* which can be found in the file epl-v10.html at the root of this distribution.
* By using this software in any fashion, you are agreeing to be bound by
* the terms of this license.
* You must not remove this notice, or any other, from this software.
**/
package clojure.tools.nrepl;
import java.io.Closeable;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import clojure.lang.AFn;
import clojure.lang.ArraySeq;
import clojure.lang.Delay;
import clojure.lang.IFn;
import clojure.lang.ISeq;
import clojure.lang.Keyword;
import clojure.lang.PersistentHashMap;
import clojure.lang.RT;
import clojure.lang.Seqable;
import clojure.lang.Symbol;
import clojure.lang.Var;
/**
* @author Chas Emerick
*/
public class Connection implements Closeable {
static {
try {
RT.var("clojure.core", "require").invoke(Symbol.intern("clojure.tools.nrepl"));
RT.var("clojure.core", "require").invoke(Symbol.intern("clojure.walk"));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Var find (String ns, String name) {
return Var.find(Symbol.intern(ns, name));
}
private static Var connect = find("clojure.tools.nrepl", "connect"),
urlConnect = find("clojure.tools.nrepl", "url-connect"),
createClient = find("clojure.tools.nrepl", "client"),
clientSession = find("clojure.tools.nrepl", "client-session"),
newSession = find("clojure.tools.nrepl", "new-session"),
message = find("clojure.tools.nrepl", "message"),
combineResponses = find("clojure.tools.nrepl", "combine-responses"),
map = find("clojure.core", "map"),
readString = find("clojure.core", "read-string"),
stringifyKeys = find("clojure.walk", "stringify-keys");
public final Closeable transport;
public final IFn client;
public final String url;
public Connection (String url) throws Exception {
this(url, Long.MAX_VALUE);
}
public Connection (String url, long readTimeout) throws Exception {
transport = (Closeable)urlConnect.invoke(this.url = url);
client = (IFn)createClient.invoke(transport, readTimeout);
}
public void close () throws IOException {
transport.close();
}
public Response send (String... kvs) {
try {
Map msg = PersistentHashMap.createWithCheck(kvs);
return new Response((ISeq)message.invoke(client, msg));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public Response sendSession (String session, String... kvs) {
try {
Map msg = PersistentHashMap.createWithCheck(kvs);
return new Response((ISeq)message.invoke(
clientSession.invoke(client, Keyword.intern("session"), session), msg));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public String newSession (String cloneSessionId) {
try {
if (cloneSessionId == null) {
return (String)newSession.invoke(client);
} else {
return (String)newSession.invoke(client, Keyword.intern("clone"), cloneSessionId);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@SuppressWarnings("unchecked")
public static class Response implements Seqable {
// would prefer to use a Delay here, but the change in IFn.invoke signatures between
// Clojure 1.2 and 1.3 makes it impossible to be compatible with both from Java
private ISeq responses;
private Map response;
private Response (final ISeq responses) {
this.responses = responses;
}
public synchronized Map combinedResponse () {
try {
if (response == null) {
response = (Map)stringifyKeys.invoke(combineResponses.invoke(responses));
responses = null;
}
return response;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public Set statuses () {
try {
return (Set)combinedResponse().get("status");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public List