github/repo2html
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
repo2html/main.scm

327 lines
11 KiB
Scheme
Raw Normal View History

don't call (main) twice when running uncompiled this set of patches gets repo2html working for me running as cli, both compiled and not, for fa! there was one markdown file in fa that lowdown throws an error about, i haven't investigated further. but i catch the error and render as plaintext instead. i haven't re-tested running as githook for pushing to fa and other repos yet.
2022-12-07 19:17:44 -05:00
#!/usr/bin/csi -s
add shebang line so we can use without compilation
2022-12-04 15:17:29 -05:00
what if we sexp'd the css too is this good (also, sorted the imports for no important reason)
2022-12-13 00:34:09 -05:00
(import
(chicken file)
(chicken format)
(chicken io)
(chicken pathname)
(chicken port)
(chicken process)
(chicken process-context)
(chicken string)
(clojurian syntax)
scss
lowdown
srfi-1 ;; list utils
srfi-13 ;; string utils
srfi-14 ;; charsets
sxml-transforms
symbol-utils ;; (unspecified-value)
utf8
)
first commit
2022-12-02 16:41:55 -05:00
Fixed environment variables and removed WEB-DIRECTORY environment variable
2022-12-07 15:32:06 -05:00
(define CLONE-URL (or (get-environment-variable "REPO2HTML_CLONE_URL") "git://git.example.com"))
(define TITLE (or (get-environment-variable "REPO2HTML_TITLE") "my git repositories"))
(define DESCRIPTION (or (get-environment-variable "REPO2HTML_DESCRIPTION") "my git repositories"))
(define H1 (or (get-environment-variable "REPO2HTML_H1") "git.example.com"))
first commit
2022-12-02 16:41:55 -05:00
deduplicate, reorganize some utility functions, inline docs
2022-12-10 16:33:38 -05:00
;; small utilities ---------------------------------
;; (bail [message [exit-status]])
;; end the program immediately.
;; if a message is provided, print it to the screen.
;; exit-status defaults to 1.
(define (bail . args)
(let-optionals args ((msg "") (status 1))
(unless (equal? "" msg) (print msg))
(exit status)))
;; decompose a path s into its constituent parts. returns values:
;;
;; root: "/" if it's an absolute path, "" if relative
;; directory-elements: a list of each directory from root, () if none
;; basename: the filename with extension removed like "readme" or ".bashrc"
;; extension: the file extension with the dot, like ".txt" or "" if none
;; relative-root: the relative path from the given path to the root
;; e.g foo/bar/baz.html -> ../../
;;
;; this is intended to provide default values that make for easier reassembly
;; into filenames.
;;
;; typical use:
;; (->> source-file
;; (pathparts)
;; (define-values (root elements basename extension relative-root)))
;;
(define (pathparts s)
(define-values (dirname basename extension)
(decompose-pathname s))
(define-values (origin root directory-elements)
(decompose-directory (or dirname "")))
;; discarding origin because idgaf about windows
(values (or root "")
(or directory-elements '())
basename
(if extension (string-append "." extension) "")
(->>
(or directory-elements '())
(map (constantly "../"))
(apply string-append))))
header id-ification improvement and other cleanup - fixed comment rendering - simplified pre-post-order rule for unspecified values - limited length of header id to 40 characters + tag name
2022-12-13 12:23:23 -05:00
;; like (substring) but doesn't break if start and end are too big/small
(define (substring* s start end)
(substring s (max start 0) (min end (string-length s))))
deduplicate, reorganize some utility functions, inline docs
2022-12-10 16:33:38 -05:00
;; main code ---------------------------------
what if we sexp'd the css too is this good (also, sorted the imports for no important reason)
2022-12-13 00:34:09 -05:00
(define mycss
(with-output-to-string
(lambda ()
(write-css
'(css
(body
(margin 0 auto)
(max-width 700px))
bugfix: css selector nav a {} is scss (// nav a)
2022-12-13 20:42:20 -05:00
((pre code)
what if we sexp'd the css too is this good (also, sorted the imports for no important reason)
2022-12-13 00:34:09 -05:00
(background-color "#ffd9df"))
(pre
(overflow scroll)
(padding 15px 20px)
(white-space pre))
(a
(color blue))
bugfix: css selector nav a {} is scss (// nav a)
2022-12-13 20:42:20 -05:00
((// nav a)
what if we sexp'd the css too is this good (also, sorted the imports for no important reason)
2022-12-13 00:34:09 -05:00
(margin-right 10px))
(hr
(border 0)
(border-bottom 1px solid black)
(margin-top 16px))
(td
(padding 0em .5em)
(vertical-align top))
(footer
(font-size small)
(text-align right))
((= id file-path)
;; change this to your liking
))))))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(define (make-sxml-template-wrapper repository-name source-files-list)
(let ((readme-file
(find (lambda (x) (member x source-files-list))
'("README" "README.md" "README.txt")))
(license-file
(find (lambda (x) (member x source-files-list))
implemented (very basic) issues list according to m455 spec
2022-12-12 09:14:15 -05:00
'("LICENSE" "LICENSE.md" "LICENSE.txt")))
(issues-present?
(find (lambda (x) (string-prefix? "ISSUES/" x)) source-files-list)))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(lambda (source-file body-sxml)
(define-values (_ _ _ _ relative-root) (pathparts source-file))
`(html (@ lang en)
(head
(title ,TITLE)
(meta (@ charset utf-8))
(meta (@ (name viewport) (content "width=device-width, initial-scale-1.0, user-scalable=yes")))
(link (@ (rel icon) (href "data:,")))
(meta (@ (name description) (content ,DESCRIPTION)))
what if we sexp'd the css too is this good (also, sorted the imports for no important reason)
2022-12-13 00:34:09 -05:00
(style ,mycss))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(body
(h1 ,H1)
(h2 ,repository-name)
(p "clone url:" ,CLONE-URL "/" ,repository-name)
(nav
add a rule to handle #<unspecified> in sxml trees this lets us use ,(when ...) when constructing sxml for optionally-present elements.
2022-12-12 12:29:06 -05:00
,(when readme-file
`(a (@ href ,relative-root "index.html") "about"))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(a (@ href ,relative-root "files.html") "files")
add a rule to handle #<unspecified> in sxml trees this lets us use ,(when ...) when constructing sxml for optionally-present elements.
2022-12-12 12:29:06 -05:00
,(when license-file
`(a (@ href ,relative-root ,license-file ".html") "license"))
,(when issues-present?
`(a (@ href ,relative-root "ISSUES.html") "issues"))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(a (@ href ,relative-root "commits.html") "commits")
(a (@ href ,relative-root "contributors.html") "contributors")))
(hr)
a little footer
2022-12-12 00:31:32 -05:00
,body-sxml
(hr)
(footer (p "Generated by " (a (@ href "https://git.m455.casa/repo2html/") "repo2html")))))))
first commit
2022-12-02 16:41:55 -05:00
header id-ification improvement and other cleanup - fixed comment rendering - simplified pre-post-order rule for unspecified values - limited length of header id to 40 characters + tag name
2022-12-13 12:23:23 -05:00
(define (slugify _ inner)
(->
inner
(pre-post-order*
`((*text* .
,(lambda (_ str)
(->
str
(string-downcase)
(string-translate "/,:;\"[]{}()=+")
(string-translate " _." "---"))))
,@alist-conv-rules*))
(flatten)
((flip map) ->string)
(string-intersperse "")
(substring* 0 40)))
assign ids to html headers this code feels like it could be way shorter and prettier and it's broken for a few edge cases, here's some i can think of: - it makes no attempt to ensure the ids that it assigns are unique on the page - there might yet be weird characters inappropriate for an id that it uses anyway - it doesn't make an attempt to limit the length of the id but other than that it pretty much works
2022-12-12 23:02:56 -05:00
(define (enumerate-tag tag inner)
header id-ification improvement and other cleanup - fixed comment rendering - simplified pre-post-order rule for unspecified values - limited length of header id to 40 characters + tag name
2022-12-13 12:23:23 -05:00
`(,tag (@ (id ,tag "-" ,(slugify tag inner))) ,inner))
assign ids to html headers this code feels like it could be way shorter and prettier and it's broken for a few edge cases, here's some i can think of: - it makes no attempt to ensure the ids that it assigns are unique on the page - there might yet be weird characters inappropriate for an id that it uses anyway - it doesn't make an attempt to limit the length of the id but other than that it pretty much works
2022-12-12 23:02:56 -05:00
first commit
2022-12-02 16:41:55 -05:00
(define (in-git-directory?)
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(not (eof-object? (call-with-input-pipe "git rev-parse --git-dir" read-line))))
first commit
2022-12-02 16:41:55 -05:00
deduplicate, reorganize some utility functions, inline docs
2022-12-10 16:33:38 -05:00
(define (git-file-is-text? path)
detect (er, ask git) if files are text or binary (ty m455 & acdw!) also remove unused procedure display-readme-html
2022-12-09 22:46:08 -05:00
(not (equal?
"-\t-\t"
(call-with-input-pipe
(string-append "git diff 4b825dc642cb6eb9a060e54bf8d69288fbee4904 --numstat HEAD -- " path)
(lambda (port) (read-line port 4))))))
first commit
2022-12-02 16:41:55 -05:00
(define (git-repository->paths-list)
(call-with-input-pipe "git ls-tree -r --name-only HEAD" read-lines))
(define (git-file->string path)
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(->
(format "git show HEAD:~a" path)
(call-with-input-pipe read-lines)
(string-intersperse "\n")))
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(define (source->sxml source-file) ;; src/main.scm
(define-values (_ _ basename extension _)
(pathparts source-file))
get relative nav links working this could use some extra thinking and cleanup, got some copy-pasted code in both populat-html-template and display-source-html. but it's working in my clone of fa!
2022-12-08 17:54:26 -05:00
(define (image-link)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
`(p (img (@ src ,basename ,extension))))
get relative nav links working this could use some extra thinking and cleanup, got some copy-pasted code in both populat-html-template and display-source-html. but it's working in my clone of fa!
2022-12-08 17:54:26 -05:00
(define (plaintext)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
`(pre ,(git-file->string source-file)))
detect (er, ask git) if files are text or binary (ty m455 & acdw!) also remove unused procedure display-readme-html
2022-12-09 22:46:08 -05:00
(define (binary)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
'(p "(Binary file)"))
`((p (@ id "file-path") ,source-file)
,(case (string->symbol extension)
((.md .markdown)
(handle-exceptions exn
(begin
(format (current-error-port) "Error parsing ~a\n" source-file)
`((p (b "There was an error parsing this file as Markdown."))
,(plaintext)))
(markdown->sxml (git-file->string source-file))))
((.jpg .jpeg .png .gif .webp .webm .apng .avif .svgz .ico)
(image-link))
((.svg)
(list (image-link) (plaintext)))
((.gz .pack .idx)
(binary))
(else
(if (git-file-is-text? source-file)
(plaintext)
(binary))))))
(define (filelist->sxml source-files-list)
`((h1 "Files")
((ul
implement commit log! also, tabulate contributors
2022-12-09 23:55:33 -05:00
,(map
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(lambda (source-file)
`(li (a (@ href ,source-file ".html") ,source-file)))
source-files-list)))))
(define (commits->sxml)
`((h1 "Commits")
(table
(tr (th "Date") (th "Ref") (th "Log") (th "Author"))
,(map
(lambda (line)
(let-values (((date ref title author) (apply values (string-split line "\t"))))
`(tr (td ,date) (td ,ref) (td ,title) (td ,author))))
(call-with-input-pipe "git log --format=format:%as%x09%h%x09%s%x09%aN HEAD" read-lines)))))
(define (contributors->sxml)
`((h1 "Contributors")
(table
(tr (th "Author") (th "Commits"))
,(map
(lambda (line)
(let-values (((commits author) (apply values (string-split line "\t"))))
`(tr (td ,author) (td ,commits))))
(call-with-input-pipe "git shortlog -ns HEAD" read-lines)))))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
implemented (very basic) issues list according to m455 spec
2022-12-12 09:14:15 -05:00
(define (issueslist->sxml source-files-list)
`((h1 "Issues")
((ul
,(filter-map
(lambda (source-file)
(and
(string-prefix? "ISSUES/" source-file)
`(li (a (@ href ,source-file ".html")
,(->
source-file
((flip format) "git show HEAD:~a")
(call-with-input-pipe read-line)
(string-trim (string->char-set "# ")))))))
source-files-list)))))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(define (generate-html-files html-repo-path)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(let* ((source-files-list (git-repository->paths-list))
(repository-name (pathname-strip-directory (string-chomp html-repo-path "/")))
(template-wrap->sxml (make-sxml-template-wrapper repository-name source-files-list)))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(define (write-with-template filename sxml)
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(let ((destination-directory (pathname-directory filename)))
whoops typo'd the path to the directory to create
2022-12-07 19:17:46 -05:00
(when destination-directory
(create-directory (make-pathname html-repo-path destination-directory) #t)))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(with-output-to-file (make-pathname html-repo-path filename)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(lambda ()
(display "<!DOCTYPE html>\n")
add a rule to handle #<unspecified> in sxml trees this lets us use ,(when ...) when constructing sxml for optionally-present elements.
2022-12-12 12:29:06 -05:00
(SXML->HTML
(pre-post-order*
header id-ification improvement and other cleanup - fixed comment rendering - simplified pre-post-order rule for unspecified values - limited length of header id to 40 characters + tag name
2022-12-13 12:23:23 -05:00
(template-wrap->sxml filename sxml)
`(;; assign all headings an id so you can link to them
(h1 . ,enumerate-tag)
(h2 . ,enumerate-tag)
(h3 . ,enumerate-tag)
(h4 . ,enumerate-tag)
(h5 . ,enumerate-tag)
;; this copied from lowdown html-serialization-rules* because it
;; is for some reason not exported??
(*COMMENT* . ,(lambda (_ str) (list #\< "!--" str "--" #\>)))
;; ignore #<unspecified> in tree
(*text* . ,(lambda (_ str) (if (unspecified? str) "" str)))
,@alist-conv-rules*))))))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(create-directory html-repo-path #t)
feature: license nav link, optional about nav link
2022-12-09 02:15:03 -05:00
;; special files
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(write-with-template "files.html" (filelist->sxml source-files-list))
(write-with-template "contributors.html" (contributors->sxml))
(write-with-template "commits.html" (commits->sxml))
feature: license nav link, optional about nav link
2022-12-09 02:15:03 -05:00
;; htmlified repo contents
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(for-each
(lambda (source-file)
(write-with-template
(string-append source-file ".html")
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
(source->sxml source-file))
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(case (string->symbol (or (pathname-extension source-file) ""))
((jpg jpeg png gif webp webm svg apng avif svgz ico)
no-op cleanup
2022-12-07 19:17:49 -05:00
(system (format "git show HEAD:~a > ~a"
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
source-file
no-op cleanup
2022-12-07 19:17:49 -05:00
(make-pathname html-repo-path source-file))))))
feature: license nav link, optional about nav link
2022-12-09 02:15:03 -05:00
source-files-list)
what if we went all-in on sxml? what would that look like? (it would look like this) - rewrote the template in sxml - deleted (first-if) as srfi-1's (find) is the same - made the template function into a factory, which might go faster? - rewrote all the special-page-generator functions to emit sxml
2022-12-12 00:14:48 -05:00
;; if README.md, README, or README.txt exists, copy that to index.html.
;; otherwise copy files.html to index.html.
(->>
'("README.md.html" "README.html" "README.txt.html" "files.html")
(map (lambda (x) (make-pathname html-repo-path x)))
(find file-exists?)
implemented (very basic) issues list according to m455 spec
2022-12-12 09:14:15 -05:00
((lambda (x) (copy-file x (make-pathname html-repo-path "index.html") #t))))
(when (file-exists? (make-pathname html-repo-path "ISSUES"))
(write-with-template "ISSUES.html" (issueslist->sxml source-files-list)))))
first commit
2022-12-02 16:41:55 -05:00
(define (main args)
fix a type check that only csc catches
2022-12-07 19:17:47 -05:00
(let-optionals args ((html-repo-path ""))
first commit
2022-12-02 16:41:55 -05:00
fix a type check that only csc catches
2022-12-07 19:17:47 -05:00
(when (equal? html-repo-path "")
deduplicate, reorganize some utility functions, inline docs
2022-12-10 16:33:38 -05:00
(bail "please specify a destination directory for html files"))
build html only when HEAD branch changes; cleanup: post-receive commit hooks receive on standard input lines of the form: old-commit new-commit ref old-commit new-commit ref old-commit new-commit ref so we can inspect those lines to determine whether or not the current branch (aka HEAD) has been changed. because there's no reason to rebuild the html representation of other branches. in future we might even use the git tree-diff between old-commit and new-commit to determine the set of files that have been added, removed, or changed, and regenerate the html representation for only those files, instead of deleting and rebuilding all files every time.
2022-12-04 15:17:31 -05:00
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(unless (in-git-directory?)
deduplicate, reorganize some utility functions, inline docs
2022-12-10 16:33:38 -05:00
(bail "woops this isn't a git directory"))
build html only when HEAD branch changes; cleanup: post-receive commit hooks receive on standard input lines of the form: old-commit new-commit ref old-commit new-commit ref old-commit new-commit ref so we can inspect those lines to determine whether or not the current branch (aka HEAD) has been changed. because there's no reason to rebuild the html representation of other branches. in future we might even use the git tree-diff between old-commit and new-commit to determine the set of files that have been added, removed, or changed, and regenerate the html representation for only those files, instead of deleting and rebuilding all files every time.
2022-12-04 15:17:31 -05:00
massive changes incl. support for images, markdown i started this off by trying to learn more about how scheme does file i/o. it seems like many of its functions just expect you'll want them to write to (current-output-port) instead of returning a string. so i thought, i wonder what it would look like if i tweak these content generator functions to just (display) their stuff, and call (with-output-to-file) and apply the html template each time i call them? and whew it kindof got away from me i totally understand if you feel like this is an unpleasant overhaul of your whole project and don't want to merge this change! anyway let's see if i can summarize the changes: - image support!! - svg image support!! it shows both the svg and its source code! - markdown support; we now render all .md files instead of showing source - using string->goodHTML instead of clean-html. turns out, it's a little annoying, in that it only returns a string if it makes no changes, but if it does, it returns a list of strings. it expects to be passed to one of the other functions in the sxml library, so that's what i do. - moved "wrap the template" outside of various "generate content" functions - simple command line use: from any git work-tree OR bare repo, run repo2html /path/to/www/output/repo-foo-bar and it will create that directory and use "repo-foo-bar" as the repo name. - made our example post-receive a bit more robust - changed env var names to have REPO2HTML_ prefix - better repo name detection and automatic caching of it in git config - moved the post-receive-specific logic to avoid generating if we're not updating HEAD into the post-receive hook itself, along with some status messages - checked directory permissions in the hook so it doesn't even attempt to run repo2html and avoids a crash
2022-12-07 04:00:52 -05:00
(generate-html-files html-repo-path)))
build html only when HEAD branch changes; cleanup: post-receive commit hooks receive on standard input lines of the form: old-commit new-commit ref old-commit new-commit ref old-commit new-commit ref so we can inspect those lines to determine whether or not the current branch (aka HEAD) has been changed. because there's no reason to rebuild the html representation of other branches. in future we might even use the git tree-diff between old-commit and new-commit to determine the set of files that have been added, removed, or changed, and regenerate the html representation for only those files, instead of deleting and rebuilding all files every time.
2022-12-04 15:17:31 -05:00
(main (command-line-arguments))
Reference in a new issue Copy permalink