/
quickapp.lisp
109 lines (90 loc) · 3.74 KB
/
quickapp.lisp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
(in-package #:quickapp)
(defun dispatch-stream-rewrite (c1 c2 input-string dispatch-function)
(let ((fstr (make-array '(0) :element-type 'base-char
:fill-pointer 0 :adjustable t)))
(with-output-to-string (s fstr)
(with-input-from-string (f input-string)
(labels
((recur (last-char)
(if (listen f)
(progn (if (and (eql last-char c1)
(eql (peek-char nil f) c2))
(format s "~a" (funcall dispatch-function f))
(write-char last-char s))
(recur (read-char f)))
(write-char last-char s))))
(recur (read-char f)))
fstr))))
(defun eval-template-string (string)
(dispatch-stream-rewrite #\# #\( string (lambda (f)
(eval (read-preserving-whitespace f)))))
(defun slurp-file (filename)
(with-open-file (stream filename)
(let ((seq (make-string (file-length stream))))
(read-sequence seq stream)
seq)))
(defun spit-file (filename string)
(with-open-file (str filename
:direction :output
:if-exists :supersede
:if-does-not-exist :create)
(format str "~a" string)))
(defun eval-template-file (file)
(eval-template-string (slurp-file file)))
(defun get-project ()
*project-name*)
(defun get-executable ()
*executable-name*)
(defun get-project-description ()
*project-description*)
(defun get-project-author ()
*project-author*)
(defun get-dependencies ()
(format nil "~{:~a~%~}" *project-dependencies*))
(defun get-utils ()
(format nil "~a.app-utils" (get-project)))
(defvar *project-name* "test")
(defvar *executable-name* "test")
(defvar *project-description* "test")
(defvar *project-author* "test")
(defvar *project-dependencies* nil)
(defvar *my-directory* (asdf:system-source-directory :quickapp))
(defun from-my-path (filename)
(merge-pathnames filename *my-directory*))
(defun do-template (project-path file &optional (name nil name-p))
(let* ((xs (split-string "." file))
(name (if name-p name (first xs)))
(type (if (> (length xs) 2) (second xs) nil))
(file-data (eval-template-file (from-my-path file))))
(spit-file (make-pathname :directory project-path
:name name
:type type)
file-data)))
(defun do-templates (project-path templates)
(mapcar #'(lambda (template) (apply #'do-template project-path template)) templates))
(defun quickapp (project-path
&key
(project-name nil pp-p)
(executable-name nil en-p)
(project-description "INSERT PROJECT DESCRIPTION HERE")
(project-author "INSERT PROJECT AUTHOR HERE")
(dependencies nil))
"Create the project from the templates"
(let ((project-path (pathname-directory (directory-namestring (concatenate 'string project-path "/")))))
(if pp-p
(setf *project-name* project-name)
(setf *project-name* (car (last project-path))))
(if en-p
(setf *executable-name* executable-name)
(setf *executable-name* *project-name*))
(setf *project-description* project-description)
(setf *project-author* project-author)
(setf *project-dependencies* dependencies)
(ensure-directories-exist (make-pathname :directory
project-path))
(do-templates project-path
`(("Makefile.template")
("project.asd.template" ,(get-project))
("project.lisp.template" ,(get-project))
("slime.lisp.template")
("app-utils.lisp.template")))))