[housekeeping] Remove reflective calls, formatting

Author: lispyclouds

src/navi/transform.clj

@@ -31,7 +31,7 @@
     RequestBody]))
 
 (defn- transform-object
-  [schema]
+  [^ObjectSchema schema]
   (let [required (->> schema
                       .getRequired
                       (into #{}))
@@ -41,22 +41,24 @@
                      (into []))]
     (into [:map {:closed false}] schemas)))
 
-(defn- transform-array [schema]
+(defn- transform-array
+  [^ArraySchema schema]
   (let [items (.getItems schema)]
     [:sequential
      (if (nil? items)
        any?
        (p/transform items))]))
 
-(defn- transform-composed [schema]
+(defn- transform-composed
+  [^ComposedSchema schema]
   (let [[schemas compose-as] (cond
                                (< 0 (count (.getAnyOf schema)))
                                [(.getAnyOf schema) :or]
-  
+
                                (< 0 (count (.getAllOf schema)))
                                [(.getAllOf schema) :and]
-  
-                               :else
+
+                               :else ;; TODO: Implement oneOf
                                (throw (IllegalArgumentException. "Unsupported composite schema. Use either anyOf, allOf")))]
     (->> schemas
          (map p/transform)
@@ -101,7 +103,6 @@
   BooleanSchema
   (p/transform [_] boolean?)
 
-  ;; TODO: Implement oneOf
   ComposedSchema
   (p/transform [schema]
     (transform-composed schema))
@@ -116,16 +117,16 @@
 
   JsonSchema
   (p/transform [schema]
-    (let [pred (fn [type]
-                 (case type
+    (let [pred (fn [typ]
+                 (case typ
                    "array" (transform-array schema)
                    "boolean" boolean?
                    "integer" int?
                    "null" nil?
                    "number" number?
                    "object" (transform-object schema)
                    "string" string?
-                   (throw (Exception. (str "Unsupported schema" schema)))))
+                   (throw (IllegalArgumentException. (format "Unsupported type %s for schema %s" typ schema)))))
           types (.getTypes schema)]
       (case (count types)
         0 (transform-composed schema)
@@ -182,3 +183,6 @@
                  body-spec
                  [:or nil? body-spec])})
       {})))
+
+(comment
+  (set! *warn-on-reflection* true))

test/navi/transform_test.clj

@@ -175,11 +175,13 @@
                           (.setAnyOf [(StringSchema.) (IntegerSchema.)])))))
     (is (= [:or string? int?]
            (p/transform (doto (JsonSchema.)
-                          (.setAnyOf [(.types (JsonSchema.) #{"string"}) (.types (JsonSchema.) #{"integer"})]))))))
+                          (.setAnyOf [(.types (JsonSchema.) #{"string"})
+                                      (.types (JsonSchema.) #{"integer"})]))))))
   (testing "allOf"
     (is (= [:and string? int?]
            (p/transform (doto (ComposedSchema.)
                           (.setAllOf [(StringSchema.) (IntegerSchema.)])))))
     (is (= [:and string? int?]
            (p/transform (doto (JsonSchema.)
-                          (.setAllOf [(.types (JsonSchema.) #{"string"}) (.types (JsonSchema.) #{"integer"})])))))))
+                          (.setAllOf [(.types (JsonSchema.) #{"string"})
+                                      (.types (JsonSchema.) #{"integer"})])))))))