Download data/repos/cl-forms/src/cl-forms.lisp from j14i/cl-ds: direct link, hf CLI and curl.
- Browser
- Download file 29.1 kB
-
https://huggingface.co/j14i/cl-ds/resolve/main/data/repos/cl-forms/src/cl-forms.lisp
- Command line
-
hf download hf://j14i/cl-ds/data/repos/cl-forms/src/cl-forms.lisp
-
curl -L -o cl-forms.lisp https://huggingface.co/j14i/cl-ds/resolve/main/data/repos/cl-forms/src/cl-forms.lisp
29.1 kB
| (in-package #:cl-forms) | |
| (defvar *form-renderer* nil "The current form renderer. | |
| Bind using WITH-FORM-RENDERER.") | |
| (defvar *default-form-renderer* :who | |
| "The default form renderer. | |
| The default renderer is CL-WHO.") | |
| (defvar *form* nil "The current form.") | |
| (defvar *base64-encode* nil "Whether to encode form parameters in base64 or not.") | |
| (defvar *field-required-message* nil | |
| "The default message to displayed when a field is required.") | |
| (defun check-duplicate-fields (fields) | |
| (when (not (equal | |
| (length (remove-duplicates fields | |
| :key (alexandria:compose 'string 'car) | |
| :test 'string=)) | |
| (length fields))) | |
| (error "Form contains duplicate fields"))) | |
| (defmethod call-with-form-renderer (renderer function) | |
| (let ((*form-renderer* renderer)) | |
| (funcall function))) | |
| (defmacro with-form-renderer (renderer &body body) | |
| "Bind *FORM-RENDERER* to RENDERER and evaluate BODY in that context." | |
| `(call-with-form-renderer ,renderer (lambda () ,@body))) | |
| (defun call-with-form-theme (form-theme function) | |
| (let ((theme (if (symbolp form-theme) | |
| (make-instance form-theme) | |
| form-theme))) | |
| (let ((*form-theme* theme)) | |
| (funcall function)))) | |
| (defmacro with-form-theme (form-theme &body body) | |
| "Bind *FORM-THEME* to FORM-THEME and evaluate BODY in that context." | |
| `(call-with-form-theme ,form-theme (lambda () ,@body))) | |
| (defun call-with-form (form function) | |
| (let ((*form* form)) | |
| (funcall function))) | |
| (defmacro with-form (form &body body) | |
| "Bind *FORM* to FORM and evaluate BODY in that context." | |
| `(call-with-form ,form (lambda () ,@body))) | |
| (defmacro defform (form-name args fields) | |
| "Define a form at top-level. | |
| ARGS are the arguments passed to FORM class via MAKE-INSTANCE. | |
| FIELDS are the form field specs. | |
| @lisp | |
| (forms:defform client-validated-form (:action \"/client-validation-post\" | |
| :client-validation t) | |
| ((name :string :value \"\" :constraints (list (clavier:is-a-string) | |
| (clavier:not-blank) | |
| (clavier:len :max 5)) | |
| :validation-triggers '(:focusin)) | |
| (single :boolean :value t) | |
| (sex :choice :choices (list \"Male\" \"Female\") :value \"Male\") | |
| (age :integer :constraints (list (clavier:is-an-integer) | |
| (clavier:greater-than -1) | |
| (clavier:less-than 200))) | |
| (email :email) | |
| (submit :submit :label \"Create\"))) | |
| @end lisp" | |
| (check-duplicate-fields fields) | |
| (alexandria:with-gensyms (fargs) | |
| `(setf (get ',form-name :form) | |
| (lambda (&rest ,fargs) | |
| (apply #'make-instance | |
| 'form | |
| :name ',form-name | |
| :fields (list ,@(loop for field in fields | |
| collect | |
| (destructuring-bind (field-name field-type &rest field-args) field | |
| `(cons ',field-name (make-form-field ,field-type :name ',(intern (string field-name)) ,@field-args))))) | |
| (append ,fargs | |
| (list ,@args))))))) | |
| (defmacro defform-builder (form-name args &body body) | |
| "Registers a function with arguments ARGS and body BODY as a form builder. | |
| BODY is expected to instantiate a FORM object using ARGS in some way. | |
| FORM-NAME is the symbol under which the FORM is registered. | |
| Use FIND-FORM with FORM-NAME and expected arguments to obtain the registered form." | |
| (alexandria:with-unique-names (form) | |
| `(setf (get ',form-name :form) | |
| (lambda ,args | |
| (let ((,form (progn ,@body))) | |
| (check-type ,form forms:form) | |
| (setf (form-name ,form) ',form-name) | |
| ,form))))) | |
| (defun make-form (name fields &rest options) | |
| (apply #'make-instance | |
| 'form | |
| :name name | |
| :fields (make-form-fields fields) | |
| options)) | |
| (defun make-form-fields (fields) | |
| (loop for field in fields | |
| collect | |
| (destructuring-bind (field-name field-type &rest field-args) field | |
| (cons field-name (apply #'make-form-field field-type | |
| :name field-name field-args))))) | |
| (defun find-form (name &rest args) | |
| "Get the form named NAME. | |
| ARGS is the list of arguments to pass to a possible form builder function. | |
| See: DEFFORM-BUILDER macro." | |
| (let ((form-builder (get name :form))) | |
| (when (not form-builder) | |
| (error "Form not found: ~A" name)) | |
| (apply form-builder args))) | |
| (defun get-form (&rest args) | |
| (warn "FORMS:GET-FORM is deprecated. Use FORMS:FIND-FORM instead.") | |
| (apply #'find-form args)) | |
| (defmacro with-form-fields (fields form &body body) | |
| "Bind FIELDS to the form fields in FORM. | |
| Example: | |
| @lisp | |
| (with-form-fields (name) form | |
| (print (field-value name))) | |
| @end lisp | |
| Also see: WITH-FORM-FIELD-VALUES " | |
| `(let ,(loop for field in fields | |
| collect `(,field (get-field ,form ',field))) | |
| ,@body)) | |
| (defmacro with-form-field-values (fields form &body body) | |
| "Bind the value of FIELDS in FORM. | |
| Example: | |
| @lisp | |
| (with-form-field-values (name) form | |
| (print name)) | |
| @end lisp" | |
| `(let ,(loop for field in fields | |
| collect `(,field (field-value (get-field ,form ',field)))) | |
| ,@body)) | |
| (defun get-field (form field-name &optional (error-p t)) | |
| (or | |
| (cdr (assoc field-name (form-fields form))) | |
| (when error-p | |
| (error "Field ~S not found in ~A" field-name form)))) | |
| (defun get-field-value (form field-name &optional (error-p t)) | |
| (declare (ignorable error-p)) | |
| (field-value (get-field form field-name))) | |
| (defun set-field-value (form field-name value) | |
| (setf (field-value (get-field form field-name)) value)) | |
| (defclass form () | |
| ((id :initarg :id | |
| :accessor form-id | |
| :initform (string (gensym)) | |
| :type string | |
| :documentation "The form id") | |
| (name :initarg :name | |
| :accessor form-name | |
| :initform (error "Provide a name for the form") | |
| :type symbol | |
| :documentation "The form name") | |
| (action :initarg :action | |
| :initform nil | |
| :type (or null string) | |
| :accessor form-action | |
| :documentation "The form action") | |
| (method :initarg :method | |
| :initform :post | |
| :type (member :get :post) | |
| :accessor form-method | |
| :documentation "The form method") | |
| (enctype :initarg :enctype | |
| :initform nil | |
| :type (or null string) | |
| :accessor form-enctype | |
| :documentation "Form encoding type. i.e. Use multipart/form-data for file uploads") | |
| (fields :initarg :fields | |
| :initform nil | |
| :accessor form-fields | |
| :documentation "Form fields") | |
| (model :initarg :model | |
| :initform nil | |
| :accessor form-model | |
| :documentation "The form model object") | |
| (csrf-protection :initarg :csrf-protection | |
| :initform nil | |
| :type boolean | |
| :accessor form-csrf-protection-p | |
| :documentation "T when csrf protection is enabled") | |
| (csrf-field-name :initarg :csrf-field-name | |
| :initform "_token" | |
| :type (or null string) | |
| :accessor form-csrf-field-name | |
| :documentation "csrf field name") | |
| (errors :initform nil | |
| :accessor form-errors | |
| :type list | |
| :documentation "Form errors after validation. An association list with elements (<field> . <field errors strings list>).") | |
| (display-errors :initarg :display-errors | |
| :initform (list :list :inline) | |
| :type list | |
| :accessor display-errors | |
| :documentation "A list containing the places where to display errors. Valid options are :list and :inline") | |
| (client-validation :initarg :client-validation | |
| :initform nil | |
| :type boolean | |
| :accessor client-validation | |
| :documentation "When T, form client validation is enabled")) | |
| (:documentation "A form")) | |
| (defmethod print-object ((form form) stream) | |
| (print-unreadable-object (form stream :type t :identity t) | |
| (format stream "~A~@{ ~A~}" | |
| (form-name form) | |
| (form-action form)))) | |
| (defmethod initialize-instance :after ((form form) &rest initargs) | |
| (declare (ignorable initargs)) | |
| (loop for field in (form-fields form) | |
| do | |
| (setf (field-form (cdr field)) form))) | |
| (defun post-parameters (&optional (request (backend-request))) | |
| (let ((post-parameters (request-post-parameters request))) | |
| (if *base64-encode* | |
| (mapcar (lambda (param) | |
| (cons (base64:base64-string-to-string (car param) :uri t) | |
| (cdr param))) | |
| post-parameters) | |
| post-parameters))) | |
| ;; csrf api | |
| (defgeneric set-form-session-csrf-token (form) | |
| (:documentation "Set csrf token for FORM and return the token.")) | |
| (defclass form-field () | |
| ((name :initarg :name | |
| :initform (error "Provide the field name") | |
| :accessor field-name | |
| :type symbol | |
| :documentation "The field name") | |
| (label :initarg :label | |
| :initform nil | |
| :type (or null string) | |
| :documentation "The field label") | |
| (value :initarg :value | |
| :initform nil | |
| :documentation "Field value") | |
| (default-value :initarg :default-value | |
| :initform nil | |
| :accessor field-default-value | |
| :documentation "Value to use when the field value is nil") | |
| (placeholder :initarg :placeholder | |
| :accessor field-placeholder | |
| :type (or null string) | |
| :initform nil | |
| :documentation "Field placeholder (text that appears when the field is empty)") | |
| (help-text :initarg :help-text | |
| :initform nil | |
| :type (or null string) | |
| :accessor field-help-text | |
| :documentation "Field help text") | |
| (parser :initarg :parser | |
| :initform nil | |
| :accessor field-parser | |
| :type (or null symbol function) | |
| :documentation "Custom field value parser") | |
| (formatter :initarg :formatter | |
| :initform nil | |
| :type (or null symbol function) | |
| :accessor field-formatter | |
| :documentation "The field formatter. The function takes two arguments, a VALUE and STREAM to format it into.") | |
| (constraints :initarg :constraints | |
| :initform nil | |
| :accessor field-constraints | |
| :documentation "A list of CLAVIER validators.") | |
| (required :initarg :required-p | |
| :initform t | |
| :type boolean | |
| :accessor field-required-p | |
| :documentation "Whether the field is required") | |
| (required-message :initarg :required-message | |
| :initform *field-required-message* | |
| :accessor field-required-message | |
| :type (or null string) | |
| :documentation "Message to display when field is required") | |
| (invalid-message :initarg :invalid-message | |
| :initform nil | |
| :accessor field-invalid-message | |
| :type (or null string function) | |
| :documentation "Message to display when field is invalid") | |
| (read-only :initarg :read-only-p | |
| :initform nil | |
| :type boolean | |
| :accessor field-read-only-p | |
| :documentation "Whether the field is read only") | |
| (disabled :initarg :disabled-p | |
| :initform nil | |
| :type boolean | |
| :accessor field-disabled-p | |
| :documentation "Whether the field is disabled") | |
| (accessor :initarg :accessor | |
| :initform nil | |
| :type (or null symbol) | |
| :accessor field-accessor | |
| :documentation "The field accessor to the underlying model") | |
| (reader :initarg :reader | |
| :initform nil | |
| :type (or null symbol function) | |
| :documentation "The function to use to read from the underlying model") | |
| (writer :initarg :writer | |
| :initform nil | |
| :type (or null symbol function) | |
| :documentation "The function to use to write to underlying model") | |
| (trim :initarg :trim-p | |
| :initform t | |
| :type boolean | |
| :accessor field-trim-p | |
| :documentation "Trim the input") | |
| (validation-triggers :initarg :validation-triggers | |
| :initform nil | |
| :accessor field-validation-triggers | |
| :documentation "Client side validation triggers. A list of :change, :focus, :focusout, :focusin, etc") | |
| (html-name :initarg :html-name | |
| :type string | |
| :documentation "The name to use in HTML. Unbound by default. If unbound, a string representation of FIELD-NAME is used. See FIELD-REQUEST-NAME.") | |
| (form :initarg :form | |
| :initform nil | |
| :type (or null form) | |
| :accessor field-form | |
| :documentation "The form the field belongs to")) | |
| (:documentation "A form field")) | |
| (defmethod print-object ((field form-field) stream) | |
| (print-unreadable-object (field stream :type t :identity t) | |
| (format stream "~S value: ~A" | |
| (field-name field) | |
| (field-value field)))) | |
| (defmethod field-label ((field form-field)) | |
| (or (slot-value field 'label) | |
| (str:sentence-case (princ-to-string (field-name field))))) | |
| (defun add-field (form field) | |
| (setf (form-fields form) | |
| (append (form-fields form) | |
| (list (cons (field-name field) field))))) | |
| (defun remove-field (form field) | |
| (setf (form-fields form) | |
| (remove (if (not (symbolp field)) | |
| (field-name field) | |
| field) | |
| (form-fields form) | |
| :key 'car))) | |
| (defmethod field-render-label-p ((field form-field)) | |
| t) | |
| (defvar *field-path* nil | |
| "This is the path in a tree of forms (subform fields) used to calculate its request name.") | |
| (defgeneric field-add-to-path (form-field form &optional path) | |
| (:method (form-field form &optional (path *field-path*)) | |
| (let ((html-name (if (slot-boundp form-field 'html-name) | |
| (slot-value form-field 'html-name) | |
| (string-downcase (string (field-name form-field)))))) | |
| (cons html-name path)))) | |
| (defun field-request-name (form-field form) | |
| (declare (ignorable form form-field)) | |
| (str:join #\. (remove-if #'str:emptyp (mapcar #'princ-to-string (reverse *field-path*))))) | |
| (defun render-field-request-name (form-field form) | |
| (let ((request-name (field-request-name form-field form))) | |
| (if *base64-encode* | |
| (base64:string-to-base64-string request-name :uri t) | |
| request-name))) | |
| (defmethod field-reader ((field form-field)) | |
| (or (slot-value field 'reader) | |
| (field-accessor field))) | |
| (defmethod field-writer ((field form-field)) | |
| (or (slot-value field 'writer) | |
| (and (field-accessor field) | |
| (fdefinition `(setf ,(field-accessor field)))))) | |
| (defmethod field-value ((field form-field)) | |
| (if (and (field-reader field) (form-model (field-form field))) | |
| (funcall (field-reader field) | |
| (form-model (field-form field))) | |
| (slot-value field 'value))) | |
| (defmethod field-value :around ((field form-field)) | |
| (or (call-next-method) | |
| (field-default-value field))) | |
| (defmethod (setf field-value) (value (field form-field)) | |
| (if (and (field-writer field) (form-model (field-form field))) | |
| (funcall (field-writer field) | |
| value | |
| (form-model (field-form field))) | |
| (setf (slot-value field 'value) value))) | |
| (defun fill-form-from-model (form model) | |
| "Fill a FORM from a MODEL. | |
| Read MODEL using FORM accessors and set the FORM field values." | |
| (loop for field in (mapcar 'cdr (forms::form-fields form)) | |
| when (forms:field-reader field) | |
| do (setf (forms:field-value field) | |
| (funcall (forms:field-reader field) model))) | |
| form) | |
| (defun fill-model-from-form (form model) | |
| "Set a MODEL's values from FORM field values." | |
| (loop for field in (mapcar 'cdr (forms::form-fields form)) | |
| when (forms:field-writer field) | |
| do (funcall (forms:field-writer field) | |
| (forms:field-value field) | |
| model))) | |
| (defclass field-validator (clavier::validator) | |
| ((field :initarg :field | |
| :initform (error "Provide the field") | |
| :accessor validator-field | |
| :documentation "The validator field")) | |
| (:metaclass closer-mop:funcallable-standard-class) | |
| (:documentation "Generic field validator. Needs a field to be initialized.")) | |
| (defun empty-value-p (val) | |
| (or (null val) | |
| (and (stringp val) | |
| (zerop (length val))))) | |
| (defgeneric validate-form-field (form-field)) | |
| (defmethod validate-form-field :around ((form-field form-field)) | |
| (cond | |
| ((and (field-required-p form-field) | |
| (empty-value-p (field-value form-field))) | |
| (values nil | |
| (list (format nil (or (field-required-message form-field) | |
| "~A is required") | |
| (or (field-label form-field) | |
| (field-name form-field)))))) | |
| ((and (not (field-required-p form-field)) | |
| (empty-value-p (field-value form-field))) | |
| (values t nil)) | |
| (t (call-next-method)))) | |
| (defmethod validate-form-field ((form-field form-field)) | |
| (let ((errors nil)) | |
| (loop for constraint in (field-constraints form-field) | |
| do | |
| (multiple-value-bind (valid-p error-msg) | |
| (funcall constraint | |
| (field-value form-field)) | |
| (when (not valid-p) | |
| (push error-msg errors)))) | |
| (values (not errors) | |
| errors))) | |
| (defmethod field-valid-p ((form-field form-field) &optional (form *form*)) | |
| "Determines if a field is valid. This method assumes the form has already | |
| been validated via validate-form." | |
| (not (find form-field (form-errors form) :key 'car))) | |
| (defgeneric format-field-value (form-field field-value &optional stream)) | |
| (defmethod format-field-value :around ((form-field form-field) field-value &optional (stream *standard-output*)) | |
| (if (field-formatter form-field) | |
| (funcall (field-formatter form-field) | |
| field-value stream) | |
| (call-next-method))) | |
| (defmethod format-field-value ((form-field form-field) field-value &optional (stream *standard-output*)) | |
| (format stream "~A" field-value)) | |
| (defun format-field-value-to-string (form-field &optional (field-value (field-value form-field))) | |
| (with-output-to-string (s) | |
| (format-field-value form-field field-value s))) | |
| (defmethod form-session-csrf-entry ((form form)) | |
| (alexandria:make-keyword (format nil "~A-CSRF-TOKEN" (form-name form)))) | |
| (defun validate-form (&optional (form *form*)) | |
| "Validates a form. Usually called after HANDLE-REQUEST. Returns multiple values; first value is true if the form is valid; second value a list of errors. | |
| The list of errors is an association list with elements (<field> . <field errors strings list>)." | |
| (setf (form-errors form) | |
| (loop for field in (form-fields form) | |
| appending | |
| (multiple-value-bind (valid-p errors) | |
| (validate-form-field (cdr field)) | |
| (when (not valid-p) | |
| (list (cons (cdr field) errors)))))) | |
| (values (null (form-errors form)) | |
| (form-errors form))) | |
| (defun form-valid-p (form) | |
| (null (form-errors form))) | |
| (defun add-form-error (field error-msg &optional (form *form*)) | |
| "Add an error on FIELD" | |
| (let ((field (if (symbolp field) | |
| (forms::get-field form field) | |
| field))) | |
| (if (assoc field (form-errors form)) | |
| (push error-msg (cdr (assoc field (form-errors form)))) | |
| (push (cons field (list error-msg)) | |
| (form-errors form))))) | |
| (defun render-form (&optional (form *form*) &rest args) | |
| "Top level function to render the web form FORM. | |
| *FORM-RENDERER* and *FORM-THEME* need to be bound. | |
| See: WITH-FORM-RENDERER, WITH-FORM-THEME" | |
| (apply #'renderer-render-form | |
| (or *form-renderer* (error "Form renderer is unbound. See *FORM-RENDERER* and WITH-FORM-RENDERER.")) | |
| *form-theme* form args)) | |
| (defun render-form-start (&optional (form *form*) &rest args) | |
| "Render only the beggining of the web form FORM. | |
| Use RENDER-FIELD, RENDER-FIELD-LABEL, etc manually, after." | |
| (apply #'renderer-render-form-start | |
| (or *form-renderer* | |
| (error "Form renderer is unbound. See *FORM-RENDERER* and WITH-FORM-RENDERER.")) | |
| *form-theme* form args)) | |
| (defun render-form-end (&optional (form *form*)) | |
| "Render the end of the web form FORM." | |
| (renderer-render-form-end *form-renderer* *form-theme* form)) | |
| (defun render-form-errors (&optional (form *form*) &rest args) | |
| "Render a section for displaying form validation errors." | |
| (when (member :list (display-errors form)) | |
| (apply #'renderer-render-form-errors *form-renderer* *form-theme* form args))) | |
| (defun render-field (field &optional (form *form*) &rest args) | |
| "Render form FIELD, both label and widget." | |
| (let ((field (if (symbolp field) | |
| (get-field form field) | |
| field))) | |
| (apply #'renderer-render-field *form-renderer* *form-theme* field form args))) | |
| (defun render-field-label (field &optional (form *form*) &rest args) | |
| "Render the label of FIELD." | |
| (let ((field (if (symbolp field) | |
| (get-field form field) | |
| field))) | |
| (unless (typep field 'submit-form-field) | |
| (apply #'renderer-render-field-label *form-renderer* *form-theme* field form args)))) | |
| (defun render-field-errors (field &optional (form *form*) &rest args) | |
| "Render the validation errors associated with FIELD." | |
| (let ((field (if (symbolp field) | |
| (get-field form field) | |
| field))) | |
| (apply #'renderer-render-field-errors *form-renderer* *form-theme* field form args))) | |
| (defun render-field-widget (field &optional (form *form*) &rest args) | |
| "Render FIELD widget." | |
| (let ((field (if (symbolp field) | |
| (get-field form field) | |
| field))) | |
| (apply #'renderer-render-field-widget *form-renderer* *form-theme* field form args))) | |
| (defgeneric renderer-render-form (renderer theme form &rest args)) | |
| (defgeneric renderer-render-form-start (renderer theme form &rest args)) | |
| (defgeneric renderer-render-form-end (renderer theme form)) | |
| (defgeneric renderer-render-form-errors (renderer theme form &rest args)) | |
| (defgeneric renderer-render-field (renderer theme field form &rest args)) | |
| (defgeneric renderer-render-field-label (renderer theme field form &rest args)) | |
| (defgeneric renderer-render-field-errors (renderer theme field form &rest args)) | |
| (defgeneric renderer-render-field-widget (renderer theme field form &rest argss)) | |
| (defmethod renderer-render-field-errors :around (renderer theme field form &rest args) | |
| (declare (ignorable args)) | |
| ;; Render field errors inline only when :inline is specified on form | |
| (when (member :inline (forms::display-errors form)) | |
| (call-next-method))) | |
| (defmethod renderer-render-form-errors :around (renderer theme form &rest args) | |
| (declare (ignorable args)) | |
| ;; Render form errors only when :list is specified on form | |
| (when (member :list (forms::display-errors form)) | |
| (call-next-method))) | |
| (defmethod renderer-render-field-widget :around (renderer theme field form &rest args) | |
| (declare (ignorable args)) | |
| (let ((*field-path* (field-add-to-path field form *field-path*))) | |
| (call-next-method))) | |
| (defgeneric backend-request () | |
| (:documentation "Return current request object for backend")) | |
| (defgeneric backend-handle-request (form request) | |
| (:documentation "Handle REQUEST for FORM. | |
| Populates FORM from parameters in HTTP request. After this, the form field contains values, but they are not validated. To validate call VALIDATE-FORM after.")) | |
| ;; Abstract away the HTTP request, so we can make cl-forms testable | |
| (defgeneric request-post-parameters (request)) | |
| (defun handle-request (&optional (form *form*) (request (backend-request))) | |
| "Populates FORM from parameters in HTTP request. After this, the form field contains values, but they are not validated. To validate call VALIDATE-FORM after." | |
| (backend-handle-request form request)) | |
| (defgeneric field-read-from-request (field form parameters)) | |
| (defmethod field-read-from-request :around (field form parameters) | |
| (let ((*field-path* (field-add-to-path field form *field-path*))) | |
| (call-next-method))) | |
| (defmethod field-read-from-request :after (field form parameters) | |
| "Use the parser function after reading the value from the request" | |
| (when (field-parser field) | |
| (setf (field-value field) | |
| (funcall (field-parser field) | |
| (field-value field))))) | |
| (defgeneric make-form-field (field-type &rest args)) | |
| (defmethod make-form-field (field-type &rest args) | |
| "Provide a good error message when a field cannot be built" | |
| (if (and (symbolp field-type) (not (keywordp field-type))) | |
| (apply #'make-instance field-type args) | |
| ;; else | |
| (error "Form field of type ~s not defined. Check that ~s is a correct field type." field-type field-type))) | |
| ;; Form templates | |
| (defun collect-replace-fields (form) | |
| (let (fields) | |
| (let ((new-form (%collect-replace-fields | |
| form | |
| (lambda (field) (push field fields))))) | |
| (values new-form fields)))) | |
| (defun %collect-replace-fields (form collect-field) | |
| (if (atom form) | |
| form | |
| (if (eql (first form) 'forms:form-field) | |
| (progn | |
| (funcall collect-field (cdr form)) | |
| `(forms:render-field ',(second form))) | |
| (loop for part in form | |
| collect | |
| (%collect-replace-fields part collect-field))))) | |
| (defmacro with-form-template ((&optional form-var) form-name args &body body) | |
| "Define a FORM named FORM-NAME and render it at the same time." | |
| (multiple-value-bind (new-body fields) (collect-replace-fields body) | |
| (let ((form-bind (or form-var (gensym "FORM")))) | |
| `(progn | |
| (defform ,form-name ,args | |
| ,fields) | |
| (let ((,form-bind (or ,form-var (find-form ',form-name)))) | |
| (with-form ,form-bind | |
| (render-form-start) | |
| ,@new-body | |
| (render-form-end))))))) | |
| (defun make-formatter (symbol) | |
| "Create a field formatter. SYMBOL is the function to call." | |
| (lambda (x stream) | |
| (format stream "~A" (funcall symbol x)))) | |
| ;; Type declarations | |
| (declaim | |
| (ftype (function (form t) (values t &optional)) fill-form-from-model) | |
| (ftype (function (form t) (values null &optional)) fill-model-from-form) | |
| (ftype (function (form) list) form-fields) | |
| (ftype (function (&optional form &rest t) string) render-form) | |
| (ftype (function (&optional form &rest t) string) render-form-errors) | |
| (ftype (function (form-field &optional form &rest t) string) render-field-errors) | |
| (ftype (function (form-field) *) field-value) | |
| (ftype (function (form-field) (or null symbol)) field-accessor) | |
| (ftype (function ((or symbol form-field) &optional form &rest t) string) render-field) | |
| (ftype (function (form-field) string) field-label) | |
| (ftype (function (form symbol &optional boolean) (or form-field null)) get-field) | |
| (ftype (function (form-field) (or null symbol function)) field-parser) | |
| (ftype (function (form-field &optional t) (values simple-string &optional)) | |
| cl-forms:format-field-value-to-string) | |
| (ftype (function (form (or symbol form-field) &optional boolean) *) cl-forms:get-field-value) | |
| (ftype function cl-forms:render-form-start) | |
| (ftype (function (&optional t) *) cl-forms:render-form-end) | |
| (ftype (function (t) (values function &optional)) cl-forms:make-formatter) | |
| (ftype (function (&optional form) (values boolean t &optional)) | |
| cl-forms:validate-form) | |
| (ftype (function (form-field t &optional t) *) cl-forms:format-field-value) | |
| (ftype (function (form) boolean) cl-forms:form-valid-p) | |
| (ftype (function (t) *) cl-forms:field-formatter) | |
| (ftype (function (form) list) form-errors) | |
| (ftype (function (symbol &rest t) form) get-form find-form) | |
| (ftype (function (t &rest t) *) cl-forms:render-field-widget) | |
| (ftype (function (t) *) cl-forms:field-reader) | |
| (ftype (function (t) *) cl-forms:field-writer) | |
| (ftype (function ((or symbol form-field) &optional form) boolean) cl-forms:field-valid-p) | |
| (ftype (function ((or symbol form-field) &optional form &rest t) *) cl-forms:render-field-label) | |
| (ftype (function (t t &optional t) *) cl-forms:add-form-error) | |
| (ftype (function (t t t) *) cl-forms:set-field-value) | |
| (ftype (function (form (or symbol form-field)) *) remove-field) | |
| (ftype (function (form form-field) *) cl-forms:add-field)) | |