lisp-rails-view 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dbdddd6688a527855ed9e36b3219ae465820bbaa
+  data.tar.gz: 09f2e4529a22af4ebccd5e28e8b6269a2b6778d9
+SHA512:
+  metadata.gz: a98ac529566451e8d0490ed66f4d5ab2c4e7e58b963d6645815402529c7d1fe6fb8fdcbd9bf3ebcd314c3da3c39dac234cf9ff5c1a25753502ba78bd013891b1
+  data.tar.gz: 102a8232c486c37e09d543190b0f375a752bfaf5d6adeb087019632e7b3f33931b4135e65b1e8223c60f47b9cfd772817ed8bb595358089345eea7282538dc9f

data/.gitignore

@@ -0,0 +1,18 @@
+*~
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lisp-rails-view.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TAHARA Yoshinori
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# lisp-rails-view
+
+lisp-rails-view is a templating engine for HTML.
+
+## Installation
+
+Install SBCL:
+
+    sudo apt-get install sbcl
+
+Add this line to your application's Gemfile:
+
+    gem 'lisp-rails-view'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+index.html.lisp
+
+```
+(:div#main
+ (:h3.title "title")
+ (:p#foo.bar "Hello"))
+```
+
+see https://github.com/quek/lisp-rails-view/tree/master/examples
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/examples/_partial.html.lisp

@@ -0,0 +1 @@
+(:p "パーシャルの中です。まみむめも。")

data/examples/index.html.lisp

@@ -0,0 +1,99 @@
+(:h1.title "lisp-rails-view Lisp ビューを書く")
+
+(:h2 "イストール")
+
+(:p "あらかじめ SBCL をインストールしておいてください。")
+
+(:h2 "使い方")
+
+(:h3 "基本")
+
+;; CL なのでこんにふうにコメントアウトできる
+#+ni
+(:pre (WITH-OUTPUT-TO-STRING (*STANDARD-OUTPUT*) (ROOM)))
+
+(:p.warning "b__ は予約語なので使えません。")
+
+"文字列はそのまま出力。<p>"
+
+(:p "タグはキーワードで書く。")
+
+(:p "(setf (readtable-case *readtable*) :preserve) しているので大文字で書くと CL"
+    (:br)
+    (IF (EVENP (GET-UNIVERSAL-TIME))
+        "偶数"
+        "奇数"))
+
+(:h3 "エスケープ")
+
+(:p "エスケープされるはず。<script>alert(\"hello\");</script>&\"'")
+
+(:h3 "Ruby のコード")
+
+(:p "ふつうに . かスペースです。")
+
+(:div
+ (:p "(= @facilities first name) => " (= @facilities first name))
+ (:p "(= @facilities.first.name) => "(= @facilities.first.name))
+ (:p "(= @facilities[1] name) => "(= @facilities[1] name)))
+
+(:p "引数は括弧でかこってください。CL の都合上 : は \\ でエスケープしてください。")
+
+(:p "(= Time.now) => "(= Time.now))
+(:p "(= Time.now.to_s (\:datetime)) => "(= Time.now.to_s (\:datetime)))
+(:p "(= @facilities.map (&\:name)) => "(= @facilities.map (&\:name)))
+(:p "(= @facilities map (&\:name) join (\"、\")) => "(= @facilities map (&\:name) join ("、")))
+
+
+(:h3 "each")
+
+(:p "ブロックは lambda にしてください。")
+
+(:p
+ (:pre "(:ul
+   (@facilities each (lambda (facility) (:li (= facility.name)))))")
+ (:ul
+  (@facilities each (lambda (facility)
+                      (:li (= facility.name))))))
+
+(:h3 "if")
+
+(:p "if もなんとか書けます。")
+
+(:p
+ (:pre
+  "(if (Time now to_i even?)
+     \"偶数\"
+     \"奇数\")")
+ (if (Time now to_i even?)
+     "偶数"
+     "奇数"))
+
+
+(:h3 "render")
+
+(:p "パーシャばもなんとか。")
+
+(:p (:pre "(= render (\"partial\"))"))
+(= render ("partial"))
+
+
+(:h3 "form")
+
+(:p "フォーム")
+
+(:p (:pre "(= form_for (Facility first)
+   (lambda (f)
+     (:p "フォームの中です<p>")
+     (:p
+      (= f label (\:name))
+      (= f text_field (\:name))
+      (= f submit))))"))
+
+(= form_for (Facility first)
+   (lambda (f)
+     (:p "フォームの中です<p>")
+     (:p
+      (= f label (\:name))
+      (= f text_field (\:name))
+      (= f submit))))

data/examples/layout.html.lisp

@@ -0,0 +1,6 @@
+(:html
+ (:head
+  (:meta :charset "utf-8")
+  (:title "lisp-rails-view Lisp ビューを書く"))
+ (:body
+  (= yield)))

data/lib/lisp-rails-view.rb

@@ -0,0 +1,39 @@
+require "lisp-rails-view/version"
+
+module LispRailsView
+  class Railtie < ::Rails::Railtie
+    initializer :lisp do |app|
+      ActiveSupport.on_load :action_view do
+        ActionView::Template.register_template_handler :lisp, LispHandler
+      end
+    end
+  end
+
+  class LispHandler
+
+    LISP = File.expand_path('../../lisp/lisp-rails-view.lisp', __FILE__)
+
+    def self.call(template)
+      file = template.identifier
+      x = `sbcl --script #{LISP} #{file}`
+      code = <<EOT
+[].tap do |b__|
+def b__.push(x)
+  if x.is_a?(Array)
+    x.map do |y|
+      push(y)
+    end
+  else
+    super(x.html_safe? ? x : ERB::Util.h(x))
+  end
+end
+#{x}
+end.flatten.join.html_safe
+EOT
+      Rails.logger.debug('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$')
+      Rails.logger.debug(code)
+      Rails.logger.debug('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$')
+      code
+    end
+  end
+end

data/lib/lisp-rails-view/version.rb

@@ -0,0 +1,3 @@
+module LispRailsView
+  VERSION = '0.0.1'
+end

data/lisp-rails-view.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/lisp-rails-view/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["TAHARA Yoshinori"]
+  gem.email         = ["read.eval.print@gmail.com"]
+  gem.description   = %q{lisp-rails-view is a templating engine for HTML.}
+  gem.summary       = %q{lisp-rails-view is a templating engine for HTML.}
+  gem.homepage      = "https://github.com/quek/lisp-rails-view"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "lisp-rails-view"
+  gem.require_paths = ["lib"]
+  gem.version       = LispRailsView::VERSION
+
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+end

data/lisp/lisp-rails-view.lisp

@@ -0,0 +1,229 @@
+(defpackage :lisp-rails-view
+  (:use :cl))
+
+(in-package :lisp-rails-view)
+
+(defvar *buffer* nil)
+
+(defclass raw ()
+  ((value :initarg :value :accessor value)))
+
+(defclass raw= (raw) ())
+
+(defclass html-safe ()
+  ((value :initarg :value :accessor value)))
+
+(defun raw (x)
+  (make-instance 'raw :value x))
+
+(defun raw= (x)
+  (make-instance 'raw= :value x))
+
+(defun html-safe (x)
+  (make-instance 'html-safe :value x))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defmacro with-reader (&body body)
+    `(let ((*readtable* (copy-readtable nil)))
+       (setf (readtable-case *readtable*) :preserve)
+       ,@body)))
+
+(defun call (template)
+  (with-reader (%call template))
+  (flush-buffer t))
+
+(defun %call (template)
+  (with-open-file (in template)
+    (loop for form = (read in nil nil)
+          while form
+          do (%eval form))))
+
+(defun flush-buffer (stream)
+  ;;TODO constant の連結
+  (loop for x in (nreverse *buffer*)
+        do (format stream "~a~%" (to-ruby-exp x))))
+
+(defun emit (x)
+  (push x *buffer*))
+
+(defun to-s (x)
+  (with-output-to-string (out)
+    (write-char #\" out)
+    (loop for c across (princ-to-string x)
+          do (cond ((char= c #\")
+                    (write-string "\\\"" out))
+                   (t
+                    (write-char c out))))
+    (write-char #\" out)))
+
+(defun to-ruby-token (x)
+  (typecase x
+    (string x
+     (to-s x))
+    (t x)))
+
+(defmethod to-ruby-exp (x)
+  (with-output-to-string (out)
+    (write-string "b__.push(" out)
+    (write-string (to-s x) out)
+    (write-string ")" out)))
+
+(defmethod to-ruby-exp ((x number))
+  (to-ruby-exp (princ-to-string x)))
+
+(defmethod to-ruby-exp ((x raw))
+  (value x))
+
+(defmethod to-ruby-exp ((x raw=))
+  (format nil "b__.push(~a)" (value x)))
+
+(defmethod to-ruby-exp ((x html-safe))
+  (format nil "b__.push(~a.html_safe)" (to-s (value x))))
+
+
+(defmethod %eval (x)
+  (emit x))
+
+(defmethod %eval ((x null)))
+
+(defmethod %eval ((x cons))
+  (cond ((eq '= (car x))
+         (emit (raw= (make-ruby-form (cdr x) t))))
+        ((keywordp (car x))
+         (process-tag x))
+        ((and (symbolp (car x))
+              (fboundp (car x)))
+         (emit (eval x)))
+        (t
+         (emit (raw (make-ruby-form x))))))
+
+(defun process-tag (form)
+  (multiple-value-bind (tag id classes) (parse-tag (car form))
+    (multiple-value-bind (attributes body /-p) (parse-tag-args (cdr form))
+      (when classes
+        (let ((kv (assoc "class" attributes :test #'string=)))
+          (when kv
+            (setf (cdr kv) `(append ',classes
+                                    (ensure-list ,(cdr kv)))
+                  classes nil))))
+      (emit (html-safe (with-output-to-string (out)
+                         (format out "<~a" tag)
+                         (when id
+                           (format out " id=\"~a\"" id))
+                         (when classes
+                           (format out " class=\"~{~a~^ ~}\"" classes))
+                         (loop for (k . v) in attributes do
+                           (if (constantp v)
+                               (if (eq v t)
+                                   (format out " ~a" k)
+                                   (format out " ~a=\"~a\"" k v))
+                               (format out "#{~a == true ? \"~a\" : \"~a=\"~a\"\"}" v k k v)))
+                         (if /-p
+                             (write-string " />" out)
+                             (write-string ">" out)))))
+      (loop for i in body
+            do (%eval i))
+      (emit (html-safe (format nil "</~a>" tag))))))
+
+(defun parse-tag (tag)
+  (let* ((str (string-downcase (symbol-name tag)))
+         (p# (position #\# str))
+         (p. (position #\. str)))
+    (cond ((and (not p#) (not p.))
+           str)
+          ((and p# (not p.))
+           (values (subseq str 0 p#)
+                   (subseq str (1+ p#))))
+          ((and (not p#) p.)
+           (values (subseq str 0 p.)
+                   nil
+                   #1=(loop for start = (1+ p.) then (1+ end)
+                            for end = (position #\. str :start start)
+                            collect (subseq str start end)
+                            unless end
+                              do (loop-finish))))
+          (t
+           (values (subseq str 0 p#)
+                   (subseq str (1+ p#) p.)
+                   #1#)))))
+
+(defun parse-tag-args (args)
+  (let (attributes)
+    (labels ((f (args)
+               (if (and (consp args)
+                        (keywordp (car args)))
+                   (progn
+                     (push (cons (string-downcase (car args)) (cadr args)) attributes)
+                     (f (cddr args)))
+                   (values (nreverse attributes)
+                           args
+                           (if (atom args)
+                               args
+                               (cdr (last args)))))))
+      (f args))))
+
+(defun blockp (form)
+  (and (consp (car (last form)))
+       (string-equal "lambda" (caar (last form)))))
+
+(defun make-ruby-form (form &optional new-buffer-p)
+  (with-output-to-string (out)
+    (let* ((blockp (blockp form))
+           (block-form (and blockp (cdar (last form))))
+           (main-form (if blockp (butlast form) form)))
+      (make-ruby-main-form (car main-form) (cdr main-form) out)
+      (when block-form
+        (format out "{~a}" (make-ruby-block block-form new-buffer-p))))))
+
+(defmethod make-ruby-main-form (first rest out)
+  (format out "~a" (to-ruby-token first))
+  (loop for i in rest
+        do (if (consp i)
+               (format out "(~{~a~^, ~})" (mapcar #'make-ruby-form (list i)))
+               (progn
+                 (write-char #\. out)
+                 (format out "~a" (to-ruby-token i))))))
+
+(defmethod make-ruby-main-form ((first (eql '|if|)) rest out)
+  (format out "if ~a~%~aelse~%~aend"
+          (make-ruby-form (car rest))
+          (make-ruby-block-body (ensure-list (cadr rest)))
+          (make-ruby-block-body (ensure-list (caddr rest)))))
+
+(defun make-ruby-block (form &optional new-buffer-p)
+  (with-output-to-string (out)
+    (let ((args (car form))
+          (body (make-ruby-block-body (cdr form))))
+      (when args
+        (format out "|~{~a~^, ~}|~%" args))
+      (if new-buffer-p
+          (format out "
+[].tap do |b__|
+def b__.push(x)
+  if x.is_a?(Array)
+    x.map do |y|
+      push(y)
+    end
+  else
+    super(x.html_safe? ? x : ERB::Util.h(x))
+  end
+end
+~a
+end.flatten.join.html_safe~%" body)
+          (format out "~a" body)))))
+
+(defun make-ruby-block-body (form)
+  (let ((*buffer* nil))
+    (loop for i in form
+          do (%eval i))
+    (with-output-to-string (out)
+      (flush-buffer out))))
+
+(defun ensure-list (x)
+  (if (consp x)
+      x
+      (list x)))
+
+(let ((template (cadr sb-ext:*posix-argv*)))
+  (when template
+    (call template)))

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: lisp-rails-view
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- TAHARA Yoshinori
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: lisp-rails-view is a templating engine for HTML.
+email:
+- read.eval.print@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/_partial.html.lisp
+- examples/index.html.lisp
+- examples/layout.html.lisp
+- lib/lisp-rails-view.rb
+- lib/lisp-rails-view/version.rb
+- lisp-rails-view.gemspec
+- lisp/lisp-rails-view.lisp
+homepage: https://github.com/quek/lisp-rails-view
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: lisp-rails-view is a templating engine for HTML.
+test_files: []