More stuff

Author: chrisrink10

src/basilisp/core.lpy

@@ -7091,17 +7091,43 @@
       (. proxy (_update-proxy-mappings mappings))
       proxy)))
 
-;; TODO: how to handle multi-arity fns
 ;; TODO: kwargs on supertypes
+;; TODO: check interface/superclass method membership
+;; TODO: check if duplicate methods
 (defmacro proxy
+  "Create a new proxy class instance.
+
+  The proxy class may implement 0 or more interface (or subclass 0 or more classes),
+  which are given as the vector ``class-and-interfaces``. If 0 such supertypes are
+  provided, Python's ``object`` type will be used.
+
+  If the supertype constructors take arguments, those arguments are given in the
+  potentially empty vector ``args``.
+
+  The remaining forms (if any) should be method overrides for any methods of the
+  declared classes and interfaces. Not every method needs to be overridden. Override
+  declarations may be multi-arity to simulate multi-arity methods. Overrides need
+  not include ``this``, as it will be automatically added and is available within
+  all proxy methods. Proxy methods may access the proxy superclass using the
+  :lpy:fn:`proxy-super` macro.
+
+  Overrides take the following form::
+
+     (single-arity []
+       ...)
+
+     (multi-arity
+       ([] ...)
+       ([arg1] ...)
+       ([arg1 & others] ...))"
   [class-and-interfaces args & fs]
   (let [formatted-arity (fn [method-name [arg-vec & body]]
-                          [(name method-name)
+                          [(munge method-name)
                            (apply list 'fn method-name (vec (concat ['this] arg-vec)) body)])
         methods         (mapcat (fn [[method-name & body]]
                                   (if (vector? (first body))
                                     (formatted-arity method-name body)
-                                    (map (partial formatted-arity method-name) body)))
+                                    (mapcat (partial formatted-arity method-name) body)))
                                 fs)]
     #_(println methods)
     `((get-proxy-class ~@class-and-interfaces) ~(apply hash-map methods) ~@args)))

tests/basilisp/test_proxies.lpy

@@ -0,0 +1,45 @@
+(ns tests.basilisp.test-proxies
+  (:require
+   [basilisp.test :as test :refer [deftest is are testing]]))
+
+(def no-op-proxy
+  (proxy [] []))
+
+(deftest get-proxy-class-test
+  (is (identical? (get-proxy-class) (get-proxy-class)))
+  (is (python/issubclass (get-proxy-class) basilisp.lang.interfaces/IProxy)))
+
+(deftest proxy-mappings-test
+  (is (= {} (proxy-mappings no-op-proxy)))
+  (is (thrown? basilisp.lang.exception/ExceptionInfo
+               (proxy-mappings (python/object)))))
+
+(deftest construct-proxy-test
+  (let [obj-proxy-cls (get-proxy-class)]
+    (is (instance? obj-proxy-cls (construct-proxy obj-proxy-cls)))
+    (is (thrown? basilisp.lang.exception/ExceptionInfo
+                 (construct-proxy python/object)))))
+
+(definterface ToString
+  (to-string [])
+  (to-string [arg1])
+  (to-string [arg1 & rest]))
+
+;; TODO: (?) needs to be mutable or setting _proxy_mappings on the instance fails
+(deftype ConcreteToString [^:mutable arg]
+  ToString
+  (to-string [this] "0")
+  (to-string [this arg1] (str "1" arg1))
+  (to-string [this arg1 & rest] (str "rest" arg1 rest)))
+
+(deftest proxy-test
+  (testing "multi-arity interface methods"
+    (let [p (proxy [ConcreteToString] [1]
+              (to-string
+                ([] "hi i am 0")
+                ([arg1] (str "i am 1 " arg1))
+                ([arg1 & args] (str "i am rest " arg1 " " args))))]
+      (is (= "hi i am 0" (.to-string p)))
+      (is (= "i am 1 yes" (.to-string p "yes")))
+      (is (= "i am rest first " (.to-string p "first")))
+      (is (= "i am rest first (:yes)" (.to-string p "first" :yes))))))