Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,72 @@
(zipmap (map name (keys m)) (vals m))))


(defn remove-modules
"Remove any modules from s that are in the sequence to-remove.

deps - in the format of the :dependencies values in the leiningen project file. [[groupid/artifact \"version\"]]
to-remove - the dependencies to remove, in the format [groupid/artifact1 groupid/artifact2] - the version is explicitly not included.

What this is doing is allowing us to specify a set of artifacts which we don't want aether to retrieve.
This is usually the case when we have another leiningen module created in IntelliJ that isn't in a repository.
See issue 18 for more details and discussion"
[deps to-remove]
(if (empty? to-remove)
deps
(remove nil?
(for [d deps
r to-remove]
(if (= (first d) r)
nil
d)))))


(defn group
"Copied from the private aether/group."
[group-artifact]
(or (namespace group-artifact) (name group-artifact)))

(defn dep-vec-to-map
"Convert a dependency vector into a map.

Arguments:
A vector in the format of a leiningen dependency declaration."
[[group-artifact version & {:keys [scope optional exclusions] :as opts}]]
(merge {:groupid (group group-artifact) :artifactid (name group-artifact) :version version} opts))

(defn dep-map-to-vec
"Convert a dependency map back into a dependency declaration vector as used in leiningen"
[{:keys [groupid artifactid version] :as m}]
(reduce #(conj %1 (first %2) (second %2))
[(if (= groupid artifactid)
(symbol groupid)
(symbol groupid artifactid))
version]
(seq (dissoc m :groupid :artifactid :version))))

(defn add-exclusions
"Add exclusions to any dependencies so that aether won't attempt to retrieve them. This is handy when
we are working with artifacts which are not in a remote repository. The particular use case that inspired this
was in Issue 18 where we had multiple modules in a project that reference each other.

This implicitly adds other modules that are loaded in IntelliJ into the exclusion list and right now supports only the
groupname/artifactid specification for an exclusion.

Arguments:
deps - in the vector of vectors format of the :dependencies values in the leiningen project file. [[groupid.artifact \"version\"]]
exclusions - the dependencies to add to each of deps exclusions list, in the format [groupid/artifact1 groupid/artifact2].
At this time we don't support any more complex exclusion definitions as we don't need them."
[deps exclusions]
(if (empty? exclusions)
deps
(for [d deps]
(let [m (dep-vec-to-map d)
e (:exclusions m)
e (if (nil? e) [] e)
exs (reduce conj e exclusions)]
(-> (assoc m :exclusions exs)
dep-map-to-vec)))))

(defn -loadDependencies
"Retrieve all of the dependencies (including transitive) which are in the :dependencies list in the project file.
- args: prj-file-path - path to the project.clj file - appears to work with relative or absolute
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -18,3 +18,91 @@
(map #(contains? % :artifactid ) result) => (has every? true?)
(map #(contains? % :file ) result) => (has every? true?)
(map #(contains? % :groupid ) result) => (has every? true?)))

;Test for the scenario when we have one leiningen module dependent on another.
;Some of these module declarations were taken from the leiningen sample project file to ensure compatibility.
(def module-a '[com.example/module "0.0.1-SNAPSHOT" :exclusions [midje]])
(def module-b '[midje "1.4.0"])
(def module-c '[org.jclouds/jclouds "1.0" :classifier "jdk15" :scope "test"])
(def module-d '[net.sf.ehcache/ehcache "2.3.1" :extension "pom"])
(def module-e '[log4j "1.2.15" :exclusions [[javax.mail/mail :extension "jar"] [javax.jms/jms :classifier "*"] com.sun.jdmk/jmxtools com.sun.jmx/jmxri]])

(facts
"About our dependency vector to map conversions and vice versa. Basically, making sure I can round trip convert these dependency vectors."
(let [a (dep-vec-to-map module-a)
b (dep-vec-to-map module-b)
c (dep-vec-to-map module-c)
d (dep-vec-to-map module-d)
e (dep-vec-to-map module-e)]
a => (contains {:groupid "com.example" :artifactid "module" :version "0.0.1-SNAPSHOT" :exclusions '[midje]})
(count a) => 4
b => (contains {:groupid "midje" :artifactid "midje" :version "1.4.0"})
(count b) => 3
c => (contains {:groupid "org.jclouds" :artifactid "jclouds" :version "1.0" :classifier "jdk15" :scope "test"})
(count c) => 5
d => (contains {:groupid "net.sf.ehcache" :artifactid "ehcache" :version "2.3.1" :extension "pom"})
(count d) => 4
e => (contains {:groupid "log4j" :artifactid "log4j" :version "1.2.15" :exclusions '[[javax.mail/mail :extension "jar"] [javax.jms/jms :classifier "*"] com.sun.jdmk/jmxtools com.sun.jmx/jmxri]})
(dep-map-to-vec a) => module-a
(dep-map-to-vec b) => module-b
(dep-map-to-vec c) => module-c
(dep-map-to-vec d) => module-d
(dep-map-to-vec e) => module-e))


(def exclusion-a 'exclude/a)
(def exclusion-b 'b)
(def exclusion-c 'com.example/module)
(def to-remove [exclusion-a exclusion-b])

(facts
"About how we remove modules from the dependencies list"
(let [result (remove-modules [module-a module-b] [exclusion-c])]
(count result) => 1
(first (take 2 result)) => module-b)
(let [result (remove-modules [module-a module-b] [])]
(count result) => 2))

(facts
"About how we add a single exclusion to a single dependency"
(let [results (add-exclusions [module-a] [exclusion-a])
r (first results)
m (dep-vec-to-map r)
exs (:exclusions m)]
(count results) => 1
(count exs) => 2
exs => (contains exclusion-a)))

(facts
"About how we add multiple exclusions to a single dependency"
(let [exclusions [exclusion-a exclusion-b exclusion-c]
results (add-exclusions [module-a] exclusions)
r (first results)
m (dep-vec-to-map r)
exs (:exclusions m)]
(count results) => 1
(count exs) => 4
exs => (contains (conj exclusions 'midje) :in-any-order)
))

(facts
"About how we add exclusions to a list of dependencies"
(let [results (add-exclusions [module-a module-b module-c module-d module-e] [exclusion-a])
r (first results)]
(count results) => 5
(doseq [r results]
(let [m (dep-vec-to-map r)
exs (:exclusions m)]
exs => (contains exclusion-a)))))

(facts
"Testing with empty exclusions vector."
(let [results (add-exclusions [module-a] [])
r (first results)
m (dep-vec-to-map r)
exs (:exclusions m)]
(count results) => 1
exs => '[midje]))

;(def project-1 (assoc p/defaults :dependencies deps))
;(cp/dependency-hierarchy :dependencies project-1)