(ns

^{:author "Sean Corfield",

:doc "A variant of clojure.java.data/to-java that uses a Builder class

to build the requested class from a hash map of properties."}

clojure.java.data.builder

(:require [clojure.java.data :as j]))

(set! *warn-on-reflection* true)

(defn- get-builder-class [^Class clazz]

(try

(resolve (symbol (str (.getName clazz) "$Builder")))

(catch Throwable _)))

(defn- get-builder ^java.lang.reflect.Method [^Class clazz methods opts]

(let [build-name (:build-fn opts)

candidates

(filter (fn [^java.lang.reflect.Method m]

(and (= 0 (alength ^"[Ljava.lang.Class;" (.getParameterTypes m)))

(= clazz (.getReturnType m))

(or (nil? build-name)

(= build-name (.getName m)))))

methods)]

(case (count candidates)

0 (throw (IllegalArgumentException.

(str "Cannot find builder method that returns "

(.getName clazz))))

1 (first candidates)

(let [builds (filter (fn [^java.lang.reflect.Method m]

(= "build" (.getName m)))

candidates)]

(case (count builds)

0 (throw (IllegalArgumentException.

(str "Cannot find 'build' method that returns "

(.getName clazz))))

(first builds))))))

(defn- find-setters [^Class builder methods props opts]

(let [candidates

(filter (fn [^java.lang.reflect.Method m]

(and (= 1 (alength ^"[Ljava.lang.Class;" (.getParameterTypes m)))

(= builder (.getReturnType m))

(or (not (re-find #"^set[A-Z]" (.getName m)))

(not (:ignore-setters? opts)))))

methods)]

(->> candidates

(reduce

(fn [setter-map ^java.lang.reflect.Method m]

(let [prop (keyword

(cond (re-find #"^set[A-Z]" (.getName m))

(let [^String n (subs (.getName m) 3)]

(str (Character/toLowerCase (.charAt n 0)) (subs n 1)))

(re-find #"^with[A-Z]" (.getName m))

(let [^String n (subs (.getName m) 4)]

(str (Character/toLowerCase (.charAt n 0)) (subs n 1)))

:else

(.getName m)))]

(if (contains? props prop)

(if (contains? setter-map prop)

(let [clazz1 (#'j/get-setter-type (second (get setter-map prop)))

clazz2 (#'j/get-setter-type m)

p-val (get props prop)]

(cond (and (instance? clazz1 p-val)

(not (instance? clazz2 p-val)))

setter-map ; existing setter is a better match:

(and (not (instance? clazz1 p-val))

(instance? clazz2 p-val))

;; this setter is a better match:

(assoc setter-map prop [(#'j/make-setter-fn m) m])

:else ; neither is an obviously better match:

(throw (IllegalArgumentException.

(str "Duplicate setter found for " prop

" in " (.getName builder) " class")))))

(assoc setter-map prop [(#'j/make-setter-fn m) m]))

;; if we are not trying to set this property, ignore the setter:

setter-map)))

{})

(reduce-kv

(fn [m k v]

(assoc m k (first v)))

{}))))

(defn- build-on [instance setters ^Class clazz props]

(reduce-kv (fn [builder k v]

(if-let [setter (get setters (keyword k))]

(apply setter [instance v])

(#'j/throw-log-or-ignore-missing-setter k clazz)))

instance

props))

(comment

;; given a class, see if it has a nested Builder class

;; otherwise we'll need to be told the builder class

;; and possibly how to create it

(get-builder-class java.util.Locale)

;; from the builder class, look for arity-0 methods then return

;; the original class -- if there's only one, use it, if there

;; are multiple and one is called "build", use it, else error

(get-builder java.util.Locale (.getMethods java.util.Locale$Builder) {})

;; setters on a builder will have single arguments and will

;; return the builder class, and will either be:

;; * B propertyName( T )

;; * B setPropertyName( T )

;; treat both as setters; thrown exception if they clash

;; (maybe an option to ignore setXyz( T ) methods?)

(find-setters java.util.Locale$Builder (.getMethods java.util.Locale$Builder) {} {})

;; general pattern will be to:

;; * get the builder class somehow

;; * get its public methods

;; * identify its builder method (or be told it)

;; * identity its setters by name

;; * construct the builder (or be given an instance?)

;; * reduce over the input hash map,

;; * -- if setter matches key,

;; * -- then invoke, use result (use j/to-java to build value here?)

;; * -- else either log, ignore, or throw (per j/*to-java-object-missing-setter*)

;; * invoke builder on result, return that

(let [clazz java.util.Locale

props {:language "fr"}

opts {}

^Class builder (get-builder-class clazz)]

(.invoke (get-builder clazz (.getMethods builder) opts)

(build-on (j/to-java builder ^clojure.lang.APersistentMap {})

(find-setters builder (.getMethods builder) props opts)

builder

props)

nil)))

(defn to-java

"Given a class and a hash map of properties, figure out the Builder class,

([clazz props] (to-java clazz props {}))

([^Class clazz props opts]

(if-let [builder (or (:builder-class opts) (get-builder-class clazz))]

(to-java clazz builder (j/to-java builder (get opts :builder-props {})) props opts)

(throw (IllegalArgumentException.

(str "Unable to deduce a builder class for " (.getName clazz))))))

([clazz instance props opts]

(let [builder (or (:builder-class opts) (class instance))]

(to-java clazz builder instance props opts)))

([^Class clazz ^Class builder instance props opts]

(.invoke (get-builder clazz (.getMethods builder) opts)

(build-on instance

(find-setters builder (.getMethods builder) props opts)

builder

props)

nil)))

(comment

(to-java java.util.Locale {:language "fr" :region "EG"}

;; these options are all defaults

{:builder-class java.util.Locale$Builder

:builder-props {}

:build-fn "build"})

(to-java java.util.Locale (java.util.Locale$Builder.) {:language "fr" :region "EG"}

;; these options are all defaults

{#_#_:builder-class java.util.Locale$Builder})

(to-java java.util.Locale (java.util.Locale$Builder.) {:language "fr" :region "EG"}

;; these options are all defaults

{:builder-class java.util.Locale$Builder

:builder-props {}

:build-fn "build"}))