formatting

src/cryogen_core/classpath_able_io.clj

@@ -75,68 +75,67 @@
                           {})
         resulting-map (merge cp-resource-map fs-resource-map)]
     (if (empty? resulting-map)
-        []
+      []
-        (vals resulting-map))))
+      (vals resulting-map))))
 
- (defn get-resource-paths-recursive ;:- [VirtualPath]
+(defn get-resource-paths-recursive ;:- [VirtualPath]
-   [fs-prefix ;:- Prefix
+  [fs-prefix ;:- Prefix
-    base-path ;:- VirtualPath
+   base-path ;:- VirtualPath
-    paths ;:- [VirtualPath]
+   paths ;:- [VirtualPath]
-    & {:keys [from-cp from-fs]
+   & {:keys [from-cp from-fs]
-       :or   {from-cp true
+      :or   {from-cp true
-              from-fs true}}]
+             from-fs true}}]
-   (map #(:virtual-path %)
+  (map #(:virtual-path %)
-        (get-resources
+       (get-resources
-         fs-prefix base-path paths
+        fs-prefix base-path paths
-         :from-cp from-cp
+        :from-cp from-cp
-         :from-fs from-fs)))
+        :from-fs from-fs)))
 
 ; TODO: Add files to keep
- (s/defn delete-resources!
+(s/defn delete-resources!
-   [virtual-path :- s/Str]
+  [virtual-path :- s/Str]
-   (let [resource-paths
+  (let [resource-paths
-         (reverse 
+        (reverse
-          (sort 
+         (sort
-           (get-resource-paths-recursive
+          (get-resource-paths-recursive
-            (str (fs/user-dir) "/")
+           (str (fs/user-dir) "/")
-            virtual-path
+           virtual-path
-            [""]
+           [""]
-            :from-cp false)))]
+           :from-cp false)))]
-     (do 
+    (do
-       (doseq [resource-path resource-paths]
+      (doseq [resource-path resource-paths]
-         (Files/delete (fs/absolut-path virtual-path resource-path))))))
+        (Files/delete (fs/absolut-path virtual-path resource-path))))))
 
 ; TODO: add ignore patterns filtering
- (defn copy-resources!
+(defn copy-resources!
-   [fs-prefix ;:- Prefix
+  [fs-prefix ;:- Prefix
-    base-path ;:- VirtualPath
+   base-path ;:- VirtualPath
-    source-paths ;:- [VirtualPath]
+   source-paths ;:- [VirtualPath]
-    target-path  ;:- VirtualPath
+   target-path  ;:- VirtualPath
-    ignore-patterns ;:- s/Str
+   ignore-patterns ;:- s/Str
-    ]
+   ]
-   (let [resources
+  (let [resources
-         (sort 
+        (sort
-          this/compare-resource
+         this/compare-resource
-          (get-resources fs-prefix base-path source-paths))]
+         (get-resources fs-prefix base-path source-paths))]
-     (if (empty? resources)
+    (if (empty? resources)
-       (throw (IllegalArgumentException. (str "resource " base-path ", "
+      (throw (IllegalArgumentException. (str "resource " base-path ", "
-                                              source-paths " not found")))
+                                             source-paths " not found")))
-       (doseq [resource resources]
+      (doseq [resource resources]
-         (let [target-path (fs/absolut-path target-path (:virtual-path resource))
+        (let [target-path (fs/absolut-path target-path (:virtual-path resource))
-               source-path (:java-path resource)]
+              source-path (:java-path resource)]
-           (when (this/is-dir? resource)
+          (when (this/is-dir? resource)
-             (Files/createDirectories target-path fs/no-attributes))
+            (Files/createDirectories target-path fs/no-attributes))
-           (when (this/is-file? resource)
+          (when (this/is-file? resource)
-             (Files/copy source-path target-path fs/overwrite-preserve-attributes)
+            (Files/copy source-path target-path fs/overwrite-preserve-attributes)))))))
-            ))))))
 
- (defn distinct-resources-by-path
+(defn distinct-resources-by-path
-   [resources]
+  [resources]
-   (loop [paths (set (map :virtual-path resources))
+  (loop [paths (set (map :virtual-path resources))
-          resources resources
+         resources resources
-          acc []]
+         acc []]
-     (cond (empty? resources) acc
+    (cond (empty? resources) acc
-           (contains? paths (:virtual-path (first resources))) (recur (disj paths (:virtual-path (first resources)))
+          (contains? paths (:virtual-path (first resources))) (recur (disj paths (:virtual-path (first resources)))
-                                                                      (rest resources)
+                                                                     (rest resources)
-                                                                      (conj acc (first resources)))
+                                                                     (conj acc (first resources)))
-           :else (recur paths (rest resources) acc))))
+          :else (recur paths (rest resources) acc))))

src/cryogen_core/classpath_able_io/cp.clj

@@ -42,8 +42,7 @@
      (when (some? java-path)
        (if is-jar-resource
          (jar/create-resource virtual-path java-path)
-         (fs/create-resource virtual-path java-path :java-classpath-filesystem))
+         (fs/create-resource virtual-path java-path :java-classpath-filesystem))))))
-       ))))
 
 (s/defn get-resources ;:- [this/Resource]
   "base-path is sensible for getting the right jar from classpath. So base-path 

src/cryogen_core/classpath_able_io/fs.clj

@@ -37,7 +37,7 @@
         (absolut-path
          (apply this/virtual-path-from-elements path-elements))]
     (when (Files/exists path-from-fs follow-link-option)
-        path-from-fs)))
+      path-from-fs)))
 
 (defn create-resource
   ([virtual-path
@@ -59,40 +59,40 @@
     source-type]
    (create-resource virtual-path (path-if-exists fs-prefix base-path virtual-path) source-type)))
 
- (defn
+(defn
-   list-entries-for-dir
+  list-entries-for-dir
-   [resource]
+  [resource]
-   (.list (.toFile (:java-path resource))))
+  (.list (.toFile (:java-path resource))))
 
- (defn get-resources ;:- [Resource]
+(defn get-resources ;:- [Resource]
-   ([fs-prefix ;:- Prefix
+  ([fs-prefix ;:- Prefix
-     base-path ;:- VirtualPath
+    base-path ;:- VirtualPath
-     paths ;:- [VirtualPath]
+    paths ;:- [VirtualPath]
-     source-type]
+    source-type]
-    (loop [paths  paths
+   (loop [paths  paths
-           result []]
+          result []]
-      (if (not (empty? paths))
+     (if (not (empty? paths))
-        (let [path-to-work-with     (first paths)
+       (let [path-to-work-with     (first paths)
-              resource-to-work-with (create-resource
+             resource-to-work-with (create-resource
-                                     fs-prefix
+                                    fs-prefix
-                                     base-path
+                                    base-path
-                                     path-to-work-with
+                                    path-to-work-with
-                                     source-type)
+                                    source-type)
-              result                (into result
+             result                (into result
-                                          [resource-to-work-with])]
+                                         [resource-to-work-with])]
-          (cond
+         (cond
-            (nil? resource-to-work-with) (recur (drop 1 paths) result)
+           (nil? resource-to-work-with) (recur (drop 1 paths) result)
-            (this/is-file? resource-to-work-with)
+           (this/is-file? resource-to-work-with)
-            (recur (drop 1 paths) result)
+           (recur (drop 1 paths) result)
-            (this/is-dir? resource-to-work-with)
+           (this/is-dir? resource-to-work-with)
-            (recur (into (drop 1 paths)
+           (recur (into (drop 1 paths)
-                         (map #(str path-to-work-with "/" %)
+                        (map #(str path-to-work-with "/" %)
-                              (list-entries-for-dir resource-to-work-with)))
+                             (list-entries-for-dir resource-to-work-with)))
-                   result)
+                  result)
-            :else []))
+           :else []))
-        (remove nil? result))))
+       (remove nil? result))))
-([fs-prefix ;:- Prefix
+  ([fs-prefix ;:- Prefix
-  base-path ;:- VirtualPath
+    base-path ;:- VirtualPath
-  paths ;:- [VirtualPath]
+    paths ;:- [VirtualPath]
-  ]
+    ]
-  (get-resources fs-prefix base-path paths :filesystem)))
+   (get-resources fs-prefix base-path paths :filesystem)))

src/cryogen_core/classpath_able_io/jar.clj

@@ -70,14 +70,14 @@
    elements-list]
   (let [norm-path-to-filter-for  (str base-path-to-filter-for "/")
         start (count norm-path-to-filter-for)]
-     (map
+    (map
-      (fn [el]
+     (fn [el]
-        (let [end (if (st/ends-with? el "/") (dec (count el)) (count el))]
+       (let [end (if (st/ends-with? el "/") (dec (count el)) (count el))]
-          (subs el start end)))
+         (subs el start end)))
-      (filter
+     (filter
-       (fn [element] (and (st/starts-with? element norm-path-to-filter-for)
+      (fn [element] (and (st/starts-with? element norm-path-to-filter-for)
-                          (not (= element norm-path-to-filter-for))))
+                         (not (= element norm-path-to-filter-for))))
-       elements-list))))
+      elements-list))))
 
 (defn filter-and-remove-for-path
   [path-to-filter-for

src/cryogen_core/new_io.clj

@@ -20,9 +20,9 @@
   [fs-prefix theme target-path ignore-patterns]
   (let [theme-path (str "templates/themes/" theme)]
     (cp-io/copy-resources! fs-prefix theme-path ["css" "js"]
-                     target-path ignore-patterns)
+                           target-path ignore-patterns)
     (cp-io/copy-resources! fs-prefix (str theme-path "/html") ["404.html"]
-                     target-path ignore-patterns)))
+                           target-path ignore-patterns)))
 
 (defn copy-html-from-theme!
   [fs-prefix theme target-path ignore-patterns]

test/cryogen_core/classpath_able_io/cp_test.clj

@@ -21,7 +21,6 @@
   (is
    (sut/path-if-exists "dummy_only_in_cp_fs")))
 
-
 (deftest should-get-resources-from-jar-and-fs-classpath
   (is (=
        []

test/cryogen_core/classpath_able_io/fs_test.clj

@@ -38,7 +38,6 @@
   (is
    (sut/path-if-exists fs-root nil "/dummy/dummy_from_fs")))
 
-
 (deftest test-list-entries-for-dir
   (is
    (= ["dummy2"

test/cryogen_core/classpath_able_io/jar_test.clj

@@ -16,15 +16,14 @@
 
 (deftest test-is-from-classpath-jar?
   (is
-   (sut/is-from-classpath-jar? (.toURI (io/resource "dummy"))))
+   (sut/is-from-classpath-jar? (.toURI (io/resource "dummy")))))
-  )
 
 (deftest test-path-if-exists
   (is
    (sut/path-if-exists "dummy/dummy_from_jar")))
-  (is
+(is
-   (= nil
+ (= nil
-      (sut/path-if-exists "not-existing")))
+    (sut/path-if-exists "not-existing")))
 
 (deftest test-get-resources
   (is

test/cryogen_core/classpath_able_io_test.clj

@@ -40,7 +40,7 @@
               "dummy2/dummy2_from_fs"])
        (sort (map ftt/filter-path
                   (sut/get-resources "fs_root" "dummy"
-                                               ["dummy_from_jar" "dummy_from_fs" "dummy2"])))))
+                                     ["dummy_from_jar" "dummy_from_fs" "dummy2"])))))
   (is (=
        [{:virtual-path   "js/dummy.js"
          :source-type   :java-classpath-filesystem