Move patterns to clj files.

Author: neshtea

src/active/clojure/pattern.cljc renamed to src/active/clojure/pattern.clj

@@ -1,12 +1,12 @@
 (ns active.clojure.pattern
-  (:require #?(:clj  [active.clojure.record :refer [define-record-type]]
-               :cljs [active.clojure.cljs.record :refer-macros [define-record-type]])
-            [active.clojure.condition :as c]
+  (:require [active.clojure.condition :as c]
             [active.clojure.functions :as f]
             [active.clojure.lens :as lens]
+            [active.clojure.record :refer [define-record-type]]
 
+            [clojure.spec.alpha :as s]
             [clojure.core.match :as match]
-            [clojure.spec.alpha :as s]))
+            [clojure.core.match.regex]))
 
 (define-record-type Pattern
   (make-pattern name clauses) pattern?
@@ -264,8 +264,7 @@
 (defn regex?
   "Is a `thing` a regex."
   [thing]
-  #?(:clj  (instance? java.util.regex.Pattern thing)
-     :cljs (instance? js/RegExp thing)))
+  (instance? java.util.regex.Pattern thing))
 
 (defn any-but
   [& exclusions]
@@ -274,7 +273,7 @@
 
 (s/def ::regex regex?)
 (s/def ::compare-fn-token #{:compare-fn})
-(s/def ::compare-fn (s/cat :compare-fn ::compare-fn-token :fn ifn?))
+(s/def ::compare-fn (s/cat :binding symbol? :compare-fn ::compare-fn-token :fn ifn?))
 
 (s/def ::or-token #{:or})
 
@@ -521,29 +520,29 @@
     `(let ~(into [] (apply concat bindings))
        ~rhs)))
 
-#?(:clj
-   (defmacro map-matcher
-     [& args]
-     (let [message              `message#
-           patterns+consequents (reduce
-                                 (fn [code [lhs* rhs]]
-                                   (let [lhs (if (symbol? lhs*) (eval lhs*) lhs*)]
-                                     (if (= lhs :else)
-                                       (concat code [lhs rhs])
-                                       (let [pattern (parse-pattern "pattern" lhs)]
-                                         (concat code
-                                                 [(pattern->lhs pattern)
-                                                  (pattern->rhs message pattern rhs)])))))
-                                 nil
-                                 (partition 2 args))]
-
-       `(fn [~message]
-          (match/match ~message ~@patterns+consequents)))))
-
-#?(:clj
-   (defmacro defpattern
-     [binding pattern]
-     `(def ~binding (quote ~pattern))))
+(defmacro map-matcher
+  [& args]
+  (let [message              `message#
+        patterns+consequents (reduce
+                              (fn [code [lhs* rhs]]
+                                (let [lhs (if (symbol? lhs*) (eval lhs*) lhs*)]
+                                  (if (= lhs :else)
+                                    (concat code [lhs rhs])
+                                    (let [pattern (if (vector? lhs)
+                                                    (parse-pattern (gensym) lhs)
+                                                    lhs)]
+                                      (concat code
+                                              [(pattern->lhs pattern)
+                                               (pattern->rhs message pattern rhs)])))))
+                              nil
+                              (partition 2 args))]
+
+    `(fn [~message]
+       (match/match ~message ~@patterns+consequents))))
+
+(defmacro defpattern
+  [binding pattern]
+  `(def ~binding ~(parse-pattern (gensym) pattern)))
 
 (define-record-type Dependency
   (make-dependency path matcher for-pattern) dependency?
@@ -602,7 +601,6 @@
 
 (defn composition->dependencies
   [composition]
-  (println "composition" composition)
   (cond
     (pattern? composition)
     (pattern->dependencies composition)

test/active/clojure/pattern_test.cljc renamed to test/active/clojure/pattern_test.clj

@@ -1,10 +1,8 @@
 (ns active.clojure.pattern-test
-  (:require #?(:clj  [active.clojure.pattern :as p]
-               :cljs [active.clojure.pattern :as p :include-macros true])
+  (:require [active.clojure.pattern :as p]
             [active.clojure.functions :as f]
-            #?(:clj  [clojure.core.match.regex])
-            #?(:clj  [clojure.test :as t]
-               :cljs [cljs.test :as t :include-macros true])))
+            [clojure.core.match.regex]
+            [clojure.test :as t]))
 
 (t/deftest parse-clause-test
   (t/testing "key exists clause"
@@ -27,8 +25,7 @@
     (t/testing "with regex"
       (let [c (p/parse-clause (list :k #"foo"))]
         (t/is (= :k (p/key-matches-clause-key c)))
-        (t/is (= "foo" #?(:clj (.pattern ^java.util.regex.Pattern (p/regex-matcher-regex (p/key-matches-clause-matcher c)))
-                          :cljs (.-source (p/regex-matcher-regex (p/key-matches-clause-matcher c))))))
+        (t/is (= "foo" (.pattern ^java.util.regex.Pattern (p/regex-matcher-regex (p/key-matches-clause-matcher c)))))
         (t/is (= 'k (p/key-matches-clause-binding c)))))
     (t/testing "with any other value"
       (t/is (= (p/make-key-matches-clause :k (p/make-constant-matcher "foo") 'k)
@@ -52,9 +49,9 @@
 
   (t/testing "with a predicate matcher"
     (t/is (= (p/make-key-matches-clause :k (p/make-predicate-matcher even?) 'Binding)
-             (p/parse-clause (list :k (list :compare-fn even?) :as 'Binding))))
+             (p/parse-clause (list :k (list 'k :compare-fn even?) :as 'Binding))))
     (t/is (= (p/make-key-matches-clause :k (p/make-predicate-matcher (f/partial = 42)) 'Binding)
-             (p/parse-clause (list :k (list :compare-fn (f/partial = 42)) :as 'Binding)))))
+             (p/parse-clause (list :k (list 'k :compare-fn (f/partial = 42)) :as 'Binding)))))
 
   (t/testing "optional clauses"
     (t/is (= (p/make-optional-clause (p/make-key-exists-clause :k p/the-existence-matcher 'k))
@@ -205,11 +202,23 @@
 
 (def predicate-matcher
   (p/map-matcher
-   [(:x (:compare-fn even?))] ::even
-   [(:x (:compare-fn odd?))] ::odd))
+   [(:x (x :compare-fn even?))] ::even
+   [(:x (x :compare-fn odd?))] ::odd))
 
 (t/deftest map-matcher-predicate-test
   (t/is (= ::even (predicate-matcher {:x 42})))
   (t/is (= ::odd (predicate-matcher {:x 41}))))
 
+(p/defpattern predicate-pattern
+  [(:x (x :compare-fn even?))])
 
+(t/deftest map-matcher-polymorphism-test
+  (t/testing "works with a pattern record"
+    (t/is (= ::even
+             ((p/map-matcher predicate-pattern ::even)
+              {:x 42}))))
+
+  (t/testing "works with pattern syntax"
+    (t/is (= ::even
+             ((p/map-matcher [(:x (x :compare-fn even?))] ::even)
+              {:x 42})))))

test/active/clojure/test_deps.cljs

@@ -8,7 +8,6 @@
             [active.clojure.record-test]
             [active.clojure.record-spec-test]
             [active.clojure.match-test]
-            [active.clojure.pattern-test]
             [active.clojure.sum-type-test]
             [active.clojure.config-test]
             [active.clojure.macro-test]

test/active/clojure/test_runner.cljs

@@ -13,7 +13,6 @@
            'active.clojure.sum-type-test
            'active.clojure.record-spec-test
            'active.clojure.match-test
-           'active.clojure.pattern-test
            'active.clojure.config-test
            'active.clojure.macro-test
            'active.clojure.functions-test