Merge branch 'decompose-profiles'

leiningen-core/src/leiningen/core/project.clj

@@ -291,10 +291,14 @@
 
 (defn- setup-profile-with-empty
   "Setup a profile map with empty defaults."
-  [raw-profile-map]
+  [raw-profile]
-  (let [empty-defaults (select-keys empty-meta-merge-defaults
+  (if (composite-profile? raw-profile)
-                                    (keys raw-profile-map))]
+    ;; TODO: drop support for partially-composite profiles in 3.0
-    (setup-map-defaults raw-profile-map empty-defaults)))
+    (mapv #(cond-> % (composite-profile? %) setup-profile-with-empty)
+          raw-profile)
+    (let [empty-defaults (select-keys empty-meta-merge-defaults
+                                      (keys raw-profile))]
+      (setup-map-defaults raw-profile empty-defaults))))
 
 (defn- setup-map-of-profiles
   "Setup a map of profile maps with empty defaults."
@@ -494,6 +498,18 @@
           (keyword? profile)
           (vary-meta update-in [:active-profiles] (fnil conj []) profile)))
 
+(defn- expand-profile* [profiles profile]
+  (let [content (get profiles profile)]
+    ;; TODO: drop "support" for partially-composite profiles in 3.0
+    (if (or (nil? content) (map? content) (some map? content))
+      [profile]
+      (mapcat (partial expand-profile* profiles) content))))
+
+(defn expand-profile
+  "Recursively expand the keyword `profile` in `project` to a sequence of
+atomic (non-composite) profile keywords."
+  [project profile] (expand-profile* (:profiles project) profile))
+
 (defn- warn-user-repos [profiles]
   (let [has-url? (fn [entry] (or (string? entry) (:url entry)))
         repo-profiles (filter #(->> (second %)

src/leiningen/with_profile.clj

@@ -21,16 +21,21 @@
         prefixes (map first profiles)]
     (cond
      (every? #{\+ \-} prefixes)
-     (distinct (reduce
+     (distinct
-                (fn [result profile]
+      (reduce (fn [result profile]
-                  (if (= \+ (first profile))
+                (let [pm (first profile), profile (keyword (subs profile 1))
-                    (concat result [(keyword (subs profile 1))])
+                      profiles (project/expand-profile project profile)]
-                    (remove #(= (keyword (subs profile 1)) %) result)))
+                  (if (= \+ pm)
-                (:active-profiles (meta project))
+                    (concat result profiles)
-                profiles))
+                    (remove (set profiles) result))))
+              (mapcat (partial project/expand-profile project)
+                      (:active-profiles (meta project)))
+              profiles))
 
      (not-any? #{\+ \-} prefixes)
-     (map keyword profiles)
+     (distinct
+      (mapcat (comp #(project/expand-profile project %) keyword)
+              profiles))
 
      :else
      (throw

test/leiningen/test/with_profile.clj

@@ -0,0 +1,34 @@
+(ns leiningen.test.with-profile
+  (:use clojure.test leiningen.with-profile))
+
+(defn- prj-map
+  ([p] (prj-map p [:default]))
+  ([p a]
+     (let [p {:profiles p}, m {:without-profiles p, :active-profiles a}]
+       (with-meta p m))))
+
+(deftest test-profiles-in-group
+  (doseq [[project pgroup expected]
+          [[(prj-map {:default [:base :dev]}) "+foo" [:base, :dev, :foo]]
+           [(prj-map {:default [:base :dev]}) "-dev" [:base]]
+           [(prj-map {:default [:base :dev]}) "-dev,+foo" [:base, :foo]]
+           [(prj-map {:default [:base :dev]}) "-default,+foo" [:foo]]
+           [(prj-map {:default [:base :dev], :foo [:bar :baz]})
+            "-default,+foo" [:bar :baz]]
+           [(prj-map {:default [:base :dev], :dev [:foo]
+                      :foo [:bar :baz], :baz [:zap]})
+            "-default,+foo" [:bar :zap]]
+           ;; TODO: drop support for partially-composite profiles in 3.0
+           [(prj-map {:default [:base :dev], :foo [:bar {:gross true}]})
+            "-default,+foo" [:foo]]]]
+    (is (= expected (profiles-in-group project pgroup))))
+  (testing "no +/- prefixes in arg"
+    (let [project (prj-map {:default [:base :dev] :foo [:bar :baz]
+                            :bar [:one :two] :baz [:three :four]})]
+      (doseq [[pgroup expected]
+              [["foo" [:one :two :three :four]]
+               ["bar" [:one :two]]
+               ["baz" [:three :four]]
+               ["bar,baz" [:one :two :three :four]]
+               ["baz,bar" [:three :four :one :two]]]]
+        (is (= expected (profiles-in-group project pgroup)))))))