fixed filenames in error messages

CHANGES.md

@@ -1,3 +1,8 @@
+# 1.2.1
+
+* fix file path displayed with failed spec
+* refactored Vigilant running to use fresh library (embedded locally)
+
 # 1.2.0
 
 * around components now execute around befores and afters

TODO.md

@@ -1,6 +1,10 @@
 # Features to add
 
-* friendly message is 'spec' dir is missing or now spec filed found.
+* friendly message if 'spec' dir is missing or no spec filed found.
+* allow runners to run files, not just directories
+* allow running to run individual example
 * mocks
 * report runs to growl, for vigilant runner
 * limelight runner
+* options for (run-specs)
+* should-be-same or some assertion that checks object reference equality

spec/speclj/report/progress_spec.clj

@@ -76,7 +76,7 @@
         (should= "1)" (lines 2))
         (should= (red "'Crazy flips' FAILED") (lines 3))
         (should= (red "Expected flips") (lines 4))
-        ;      (should= "/Users/micahmartin/Projects/clojure/speclj/spec/speclj/report/progress_spec.clj:54" (lines 5))
+;        (should= "/Users/micahmartin/Projects/clojure/speclj/spec/speclj/report/progress_spec.clj:67" (lines 5))
         (should= "" (lines 6))
         (should= "2)" (lines 7))
         (should= (red "'Crazy spins' FAILED") (lines 8))

speclj.iml

@@ -41,6 +41,15 @@
         <SOURCES />
       </library>
     </orderEntry>
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="file://$MODULE_DIR$/src" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>
 

src/speclj/reporting.clj

@@ -1,12 +1,21 @@
 (ns speclj.reporting
   (:use
     [speclj.exec :only (pass? fail?)]
-    [speclj.config :only (*reporter* *color?* *full-stack-trace?*)]))
+    [speclj.config :only (*reporter* *color?* *full-stack-trace?*)]
+    [clojure.string :as string :only (split)]))
+
+(defn- classname->filename [classname]
+  (let [root-name (first (split classname #"\$"))]
+    (str
+      (string/replace root-name "." (System/getProperty "file.separator"))
+      ".clj")))
 
 (defn failure-source [exception]
-  (let [source (nth (.getStackTrace exception) 0)]
-    (if-let [filename (.getFileName source)]
-      (str (.getCanonicalPath (java.io.File. filename)) ":" (.getLineNumber source))
+  (let [source (nth (.getStackTrace exception) 0)
+        classname (.getClassName source)
+        filename (classname->filename classname)]
+    (if-let [url (.getResource (clojure.lang.RT/baseLoader) filename)]
+      (str (.getFile url) ":" (.getLineNumber source))
       "Unknown source")))
 
 (defn tally-time [results]

src/speclj/run/vigilant.clj

@@ -9,160 +9,6 @@
     [speclj.running Runner]
     [java.util.concurrent ScheduledThreadPoolExecutor TimeUnit]))
 
-;; Resolving ns names ---------------------------------------------------------------------------------------------------
-;
-;(defn ns-to-filename [ns]
-;  (str (apply str (replace {\. \/ \- \_} (name ns))) ".clj"))
-;
-;(defn ns-to-file [ns]
-;  (let [relative-filename (ns-to-filename ns)
-;        url (.getResource (.getContextClassLoader (Thread/currentThread)) relative-filename)]
-;    (if (and url (= "file" (.getProtocol url)))
-;      (File. (.getFile url))
-;      nil)))
-;
-;(defn- ns-form? [form]
-;  (and (list? form) (= 'ns (first form))))
-;
-;(defn read-ns-form [file]
-;  (try
-;    (let [reader (PushbackReader. (FileReader. file))]
-;      (try
-;        (loop [form (read reader)]
-;          (if (ns-form? form)
-;            form
-;            (recur (read reader))))
-;        (finally (.close reader))))
-;    (catch Exception e nil)))
-;
-;; Parsing the ns form --------------------------------------------------------------------------------------------------
-;
-;(defn- compose-ns [prefix lib]
-;  (if prefix
-;    (symbol (str prefix \. lib))
-;    lib))
-;
-;(defn- ns-for-part [prefix arg]
-;  (cond
-;    (symbol? arg) (compose-ns prefix arg)
-;    (and (vector? arg) (or (nil? (second arg)) (keyword? (second arg)))) (compose-ns prefix (first arg))
-;    :else (map #(ns-for-part (compose-ns prefix (first arg)) %) (rest arg))))
-;
-;(defn- depending-names-of-part [args]
-;  (map #(ns-for-part nil %) (filter (complement keyword?) (rest args))))
-;
-;(defn depending-names-of [ns-form]
-;  (let [dependency-parts (filter #(and (list? %) (#{:use :require} (first %))) ns-form)
-;        ns-list (map #(depending-names-of-part %) dependency-parts)]
-;    (set (flatten ns-list))))
-;
-;(defn- depending-files-of [ns-form]
-;  (if ns-form
-;    (let [dependency-names (depending-names-of ns-form)
-;          dependency-filenames (map #(ns-to-file %) dependency-names)]
-;      (vec (filter identity dependency-filenames)))
-;    []))
-;
-;(defn- ns-of [ns-form]
-;  (if ns-form
-;    (second ns-form)
-;    nil))
-;
-;; File tracking --------------------------------------------------------------------------------------------------------
-;
-;(deftype FileTracker [ns mod-time dependencies]
-;  Object
-;  (toString [this] (str "ns: " ns " mod-time: " mod-time " dependencies: " dependencies)))
-;
-;(defn new-file-tracker [ns mod-time dependencies]
-;  (FileTracker. ns mod-time dependencies))
-;
-;(defn- modified? [file tracker]
-;  (> (.lastModified file) (.mod-time tracker)))
-;
-;(declare update-tracking-for-files)
-;(defn- update-tracking-for-file [listing file batch]
-;  (let [tracker (get listing key)
-;        ns-form (read-ns-form file)
-;        no-update-required (not (or (nil? tracker) (modified? file tracker)))]
-;    (if no-update-required
-;      [listing batch]
-;      (let [dependencies (depending-files-of ns-form)
-;            [listing batch] (update-tracking-for-files listing dependencies batch)
-;            ns (ns-of ns-form)
-;            updated-tracker (new-file-tracker ns (.lastModified file) dependencies)]
-;        [(assoc listing file updated-tracker) batch]))))
-;
-;(defn- update-tracking-for-files
-;  ([listing files] (nth (update-tracking-for-files listing files #{}) 0))
-;  ([listing files batch]
-;    (loop [[listing batch] [listing batch] files files]
-;      (if (not (seq files))
-;        [listing batch]
-;        (let [file (first files)]
-;          (if (contains? batch file)
-;            (recur [listing batch] (rest files))
-;            (recur (update-tracking-for-file listing file (conj batch file)) (rest files))))))))
-;
-;; Tracker Dependencies -------------------------------------------------------------------------------------------------
-;
-;(defn- depends-on? [dependency listing dependent]
-;  (some (partial = dependency) (.dependencies (get listing dependent))))
-;
-;(defn- has-dependent? [listing file]
-;  (some #(depends-on? file listing %) (keys listing)))
-;
-;(defn- with-dependency [new-dependents dependents file tracker]
-;  (if (some dependents (.dependencies tracker))
-;    (conj new-dependents file)
-;    new-dependents))
-;
-;(defn dependents-of
-;  ([listing files] (dependents-of listing (set files) #{}))
-;  ([listing files dependents]
-;    (loop [files files dependents dependents]
-;      (let [new-dependents (reduce (fn [new-dependents [file tracker]] (with-dependency new-dependents files file tracker)) #{} listing)]
-;        (if (seq new-dependents)
-;          (recur new-dependents (into dependents new-dependents))
-;          dependents)))))
-;
-;
-;; High level -----------------------------------------------------------------------------------------------------------
-;
-;(defn track-files [runner & files]
-;  (swap! (.listing runner) #(update-tracking-for-files % files)))
-;
-;(defn updated-files [runner directories]
-;  (let [observed-files (set (apply clj-files-in directories))
-;        listing @(.listing runner)
-;        tracked-files (set (keys listing))
-;        new-files (difference observed-files tracked-files)
-;        modified-files (filter #(modified? % (get listing %)) tracked-files)]
-;    (concat new-files modified-files)))
-;
-;(defn clean-deleted-files
-;  ([runner] (swap! (.listing runner)
-;    (fn [listing] (clean-deleted-files listing (filter #(not (.exists %)) (keys listing))))))
-;  ([listing files-to-delete]
-;    (if (not (seq files-to-delete))
-;      listing
-;      (let [dependencies (reduce #(into %1 (.dependencies (get listing %2))) [] files-to-delete)
-;            listing (apply dissoc listing files-to-delete)
-;            unused-dependencies (filter #(not (has-dependent? listing %)) dependencies)]
-;        (clean-deleted-files listing unused-dependencies)))))
-;
-;(defn reload-files [runner & files]
-;  (let [listing @(.listing runner)
-;        trackers (vec (filter identity (map listing files)))
-;        nses (vec (filter identity (map #(.ns %) trackers)))]
-;    (if (seq nses)
-;      (do
-;        (doseq [ns nses] (remove-ns ns))
-;        (dosync (alter @#'clojure.core/*loaded-libs* difference (set nses)))
-;        (apply require nses)))))
-
-; Main -----------------------------------------------------------------------------------------------------------------
-
 (def start-time (atom 0))
 
 (defn- report-update [report]