nydp-html 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40fa5ecff67b7c001d0e445507ce177ceadecf13
-  data.tar.gz: c5850142ea885409dc663241084067325f4a4fe7
+  metadata.gz: 8d01a7d3f36a0d99679fd19d725ff85a643a6b06
+  data.tar.gz: dab0a28d59f58f676f0e646ad9a0aace4b86848d
 SHA512:
-  metadata.gz: edd1ef38d177f7a64c73e344722c1a76d7909f768868be3b77b639f2c269f60c182ea3f00af84b53493c67c2908ea7d2b98e259201e99b90d690ef6aba6885fb
-  data.tar.gz: 77add9b61ae9d7cba66cc4ed321870ad339610445a7d1e1342104108dcbf48bd276b4292e04e97c54c262e4f5f05cbe320f607aa8331f9375a67034b184e5846
+  metadata.gz: e03798eed60035ddeb288e1564a2d798b998dc7cc97c960c96dd67b6b273ac976813d4629b2c723d86ca699247eb4ac57c7ce03b734c1e78d80b3afb5ed37b94
+  data.tar.gz: 090d0f5628bc87d76854a6306c6d5b866175be73fce881d357fd543c36fe60b3b7d0b0e2b00582a74b668a99f57a727f7883fe782ea3db633ef4266dc83cd7b5

data/README.md

@@ -1,6 +1,6 @@
 # Nydp::Html
 
-TODO: Write a gem description
+Nydp::Html is the amazing HTML templating library for use with NYDP.
 
 ## Installation
 
@@ -20,7 +20,47 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+#### render-as-textile:
+
+```lisp
+    (render-as-textile "hello world")                   ;=> "<p>hello world</p>"
+    (render-as-textile (get-some-text-from 'somewhere)) ;=> (textile-to-html (get-some-text-from 'somewhere))
+    (render-as-textile "hello ~name")                   ;=> (string-pieces "<p>hello" name "<p>")
+```
+
+#### render-as-haml:
+
+```lisp
+    (render-as-haml "%p hello world")                ;=> "<p>hello world</p>"
+    (render-as-haml (get-some-text-from 'somewhere)) ;=> (haml-to-html (get-some-text-from 'somewhere))
+    (render-as-haml "%p hello ~name")                ;=> (string-pieces "<p>hello" name "<p>")
+```
+
+If you want to generate a function that returns html from a string that you've stored elsewhere (in a CMS for example),
+
+```lisp
+; assume 'content is the text as stored in your CMS
+
+(mac make-renderer (name content)
+  `(def ,name ()
+     (textile-to-html ,(parse-in-string content))))
+
+(make-renderer homepage "hello \~person - \"click here\":/buy-now to buy some stuff *now*")
+
+(assign person "Cleopatra")
+
+(homepage) ;=> returns "<p>hello Cleopatra &#8211; <a href=\"/buy-now\">click here</a> to buy some stuff <strong>now</strong></p>"
+```
+
+Same idea if your CMS text uses HAML markup, just use 'haml-to-html instead of 'textile-to-html. NYDP uses tilde for string
+interpolations, don't be inhibited:
+
+```lisp
+
+(make-renderer homepage "hello ~(db-lookup current-user contact-info name), you have *~(shopping-cart.size)*
+                         items in your shopping cart. ~(render-shopping-cart) %(call-to-action)~(buy-now-button)%")
+
+```
 
 ## Contributing
 

data/lib/lisp/tests/haml-tests.nydp

@@ -0,0 +1,101 @@
+(register-test
+ '(suite "haml"
+         ("build a function to render a given haml string with the given arguments"
+          (pre-compile '(render-as-haml ".funny#my-id hello ~context.name this file was in ~(just source.name)."))
+          (string-pieces
+           "<div class='funny' id='my-id'>hello "
+           (interpolate (hash-get context 'name))
+           " this file was in "
+           (interpolate (hash-get source 'name))
+           ".</div>\n"))
+
+         ("render a plain haml string to html"
+          (render-as-haml "%h1 header text
+
+%p paragraph text
+
+%ul
+  %li item 1
+  %li item 2
+")
+          "<h1>header text</h1>
+<p>paragraph text</p>
+<ul>
+  <li>item 1</li>
+  <li>item 2</li>
+</ul>\n")
+
+         ("compile a string with interpolations to an instruction to generate haml"
+          (pre-compile '(render-as-haml "%h1 HEADER
+
+%p ~a and ~b and ~(c 3)
+
+%ul
+  %li item ~(assign counter (+ counter 1))
+  %li item ~(assign counter (+ counter 1))
+  %li item ~(assign counter (+ counter 1))
+"))
+
+          (string-pieces "<h1>HEADER</h1>\n<p>"
+                         (interpolate a) " and " (interpolate b) " and " (interpolate (c 3))
+                         "</p>\n<ul>\n  <li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n  <li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n  <li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n</ul>\n" nil))
+
+         ("compile a function invocation to render as haml"
+          (pre-compile '(render-as-haml a))
+          (haml-to-html a))
+
+         ("compile a plain string with no interpolations to an instruction to generate haml"
+          (pre-compile '(render-as-haml "%h1 HEADER
+
+%p para
+
+%ul
+  %li item 1
+  %li item 2
+"))
+          "<h1>HEADER</h1>
+<p>para</p>
+<ul>
+  <li>item 1</li>
+  <li>item 2</li>
+</ul>
+")
+
+         ("compile a simple string with one interpolation to render html"
+          (pre-compile '(render-as-haml "hello ~name "))
+          (string-pieces "hello " (interpolate name) "\n"))
+
+         ("render a simple string with one interpolation to html"
+          (let name "conan"
+               (render-as-haml "hello ~name"))
+          "hello conan\n")
+
+         ("render a string with interpolations to html"
+          (with (a 1 b 2 c (fn (x) (* 2 x)) counter 0)
+                (render-as-haml "%h1 HEADER
+
+%p ~a and ~b and ~(c 3)
+
+%ul
+  %li item ~(assign counter (+ counter 1))
+  %li item ~(assign counter (+ counter 1))
+  %li item ~(assign counter (+ counter 1))
+"))
+
+          "<h1>HEADER</h1>
+<p>1 and 2 and 6</p>
+<ul>
+  <li>item 1</li>
+  <li>item 2</li>
+  <li>item 3</li>
+</ul>
+")
+
+         ("render a variable to html"
+          (with (a "%p hello, world") (render-as-haml a))
+
+          "<p>hello, world</p>\n")
+))

data/lib/lisp/tests/textile-tests.nydp

@@ -1,14 +1,13 @@
 (register-test
  '(suite "textile"
          ("build a function to render a given textile string with the given arguments"
-         (pre-compile '(textile-build-function (a b c) "hello ~context.name this file was in ~(just source.name)."))
-         (fn (a b c)
-             (string-pieces
-              "<p>hello "
-              (interpolate (hash-get context 'name))
-              " this file was in "
-              (interpolate (hash-get source 'name))
-              ".</p>")))
+          (pre-compile '(render-as-textile "hello ~context.name this file was in ~(just source.name)."))
+          (string-pieces
+           "<p>hello "
+           (interpolate (hash-get context 'name))
+           " this file was in "
+           (interpolate (hash-get source 'name))
+           ".</p>"))
 
          ("render a plain textile string to html"
           (render-as-textile "h1. header text
@@ -21,38 +20,38 @@ paragraph text
           "<h1>header text</h1>\n<p>paragraph text</p>\n<ul>\n\t<li>item 1</li>\n\t<li>item 2</li>\n</ul>")
 
          ("compile a string with interpolations to an instruction to generate textile"
-                (compile-as-textile "h1. HEADER
+          (pre-compile '(render-as-textile "h1. HEADER
 
 ~a and ~b and ~(c 3)
 
 * item ~(assign counter (+ counter 1))
 * item ~(assign counter (+ counter 1))
 * item ~(assign counter (+ counter 1))
-")
+"))
 
-                (string-pieces "<h1>HEADER</h1>\n<p>"
-                               (interpolate a) " and " (interpolate b) " and " (interpolate (c 3))
-                               "</p>\n<ul>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
-                               "</li>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
-                               "</li>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
-                               "</li>\n</ul>" nil))
+          (string-pieces "<h1>HEADER</h1>\n<p>"
+                         (interpolate a) " and " (interpolate b) " and " (interpolate (c 3))
+                         "</p>\n<ul>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n\t<li>item " (interpolate (assign counter (+ counter 1)))
+                         "</li>\n</ul>" nil))
 
          ("compile a function invocation to render as textile"
-          (compile-as-textile a)
+          (pre-compile '(render-as-textile a))
           (textile-to-html a))
 
          ("compile a plain string with no interpolations to an instruction to generate textile"
-                (compile-as-textile "h1. HEADER
+          (pre-compile '(render-as-textile "h1. HEADER
 
 para
 
 * item 1
 * item 2
-")
-                "<h1>HEADER</h1>\n<p>para</p>\n<ul>\n\t<li>item 1</li>\n\t<li>item 2</li>\n</ul>")
+"))
+          "<h1>HEADER</h1>\n<p>para</p>\n<ul>\n\t<li>item 1</li>\n\t<li>item 2</li>\n</ul>")
 
          ("compile a simple string with one interpolation to render html"
-          (compile-as-textile "hello ~name ")
+          (pre-compile '(render-as-textile "hello ~name "))
           (string-pieces "<p>hello " (interpolate name) "</p>"))
 
          ("render a simple string with one interpolation to html"
@@ -77,5 +76,4 @@ para
           (with (a "hello, world") (render-as-textile a))
 
           "<p>hello, world</p>")
-
 ))

data/lib/lisp/to-html.nydp

@@ -0,0 +1,47 @@
+;
+; render-as-textile:
+;
+; (render-as-textile "hello world")                   ;=>  "<p>hello world</p>"
+; (render-as-textile (get-some-text-from 'somewhere)) ;=>  (textile-to-html (get-some-text-from 'somewhere))
+; (render-as-textile "hello ~name")                   ;=> (string-pieces "<p>hello" name "<p>")
+;
+; render-as-haml:
+;
+; (render-as-haml "%p hello world")                ;=> "<p>hello world</p>"
+; (render-as-haml (get-some-text-from 'somewhere)) ;=> (haml-to-html (get-some-text-from 'somewhere))
+; (render-as-haml "%p hello ~name")                ;=>  (string-pieces "<p>hello" name "<p>")
+;
+
+(def interpolate (arg) arg)
+
+(def html-process-parts (parts converter)
+  (let separator (random-string 20)
+       (string-split (converter.method (joinstr "~(just converter.esc)~(just separator)~(just converter.esc)"
+                                               parts))
+                     separator)))
+
+(def html-interpolatify-arg (tuple)
+     (if (cadr tuple)
+         `(interpolate ,(cadr tuple))
+         nil))
+
+(def html-build-interpolator (pieces converter)
+     (let tuples (pairs pieces)
+          `(string-pieces ,@(apply + (zip (html-process-parts (map car tuples) converter)
+                                          (map html-interpolatify-arg tuples))))))
+
+(mac render-as-haml (arg)
+     (if (isa 'string arg)
+         (haml-to-html arg)
+         (and (pair? arg)
+              (eq? 'string-pieces (car arg)))
+         (html-build-interpolator (cdr arg) { method haml-to-html esc "" })
+         `(haml-to-html ,arg)))
+
+(mac render-as-textile (arg)
+     (if (isa 'string arg)
+         (textile-to-html arg)
+         (and (pair? arg)
+              (eq?   'string-pieces (car arg)))
+         (html-build-interpolator (cdr arg) { method textile-to-html esc "==" })
+         `(textile-to-html ,arg)))

data/lib/nydp/html.rb

@@ -1,3 +1,4 @@
+require "haml"
 require "redcloth"
 require "nydp"
 require "nydp/literal"
@@ -16,7 +17,7 @@ module Nydp
       end
 
       def loadfiles
-        b = relative_path('../lisp/textile.nydp')
+        b = relative_path('../lisp/to-html.nydp')
         [b]
       end
 
@@ -26,6 +27,27 @@ module Nydp
 
       def setup ns
         Symbol.mk("textile-to-html",  ns).assign(Nydp::Html::TextileToHtml.new)
+        Symbol.mk("haml-to-html",     ns).assign(Nydp::Html::HamlToHtml.new)
+      end
+    end
+
+    class HamlToHtml
+      def convert_from_haml convertible
+        Haml::Engine.new(convertible, suppress_eval: true).render
+      rescue Exception => e
+        if e.line
+          lines = convertible.split(/\n/)
+          beginning = e.line - 2
+          beginning = 0 if beginning < 0
+          selection = lines[beginning...(e.line + 1)].join "\n"
+          "#{e.message}<br/>line #{e.line}<br/><br/><pre>#{selection}</pre>"
+        else
+          e.message
+        end
+      end
+
+      def invoke vm, args
+        vm.push_arg Nydp::StringAtom.new convert_from_haml(args.car.to_s)
       end
     end
 

data/lib/nydp/html/version.rb

@@ -1,5 +1,5 @@
 module Nydp
   module Html
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp-html
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-07 00:00:00.000000000 Z
+date: 2015-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,8 +122,10 @@ files:
 - README.md
 - Rakefile
 - bin/nydp-tests
+- lib/lisp/haml.nydp
+- lib/lisp/tests/haml-tests.nydp
 - lib/lisp/tests/textile-tests.nydp
-- lib/lisp/textile.nydp
+- lib/lisp/to-html.nydp
 - lib/nydp/html.rb
 - lib/nydp/html/version.rb
 - nydp-html.gemspec

data/lib/lisp/textile.nydp

@@ -1,71 +0,0 @@
-;
-; render-as-textile:
-;
-; ================================================================================
-;
-; the simplest case:
-;
-; (render-as-textile "hello world")
-;
-; expands to
-;
-; "<p>hello world</p>"
-;
-; ================================================================================
-;
-; next case,
-;
-; (render-as-textile (get-some-text-from 'somewhere))
-;
-; expands to
-;
-; (textile-to-html (get-some-text-from 'somewhere))
-;
-; ================================================================================
-;
-; the most useful case:
-;
-; (render-as-textile "hello ~name")
-;
-; expands to :
-;
-; (string-pieces "<p>hello" name "<p>")
-;
-;
-
-(def interpolate (arg) arg)
-
-(def textile-process-parts (parts)
-  (let separator (random-string 20)
-       (string-split (textile-to-html (joinstr "==~{separator}=="
-                                               parts))
-                     separator)))
-
-(def textile-interpolatify-arg (tuple)
-     (if (cadr tuple)
-         `(interpolate ,(cadr tuple))
-         nil))
-
-(def build-textile-interpolator (pieces)
-     (let tuples (pairs pieces)
-          `(string-pieces ,@(apply + (zip (textile-process-parts (map car tuples))
-                                          (map textile-interpolatify-arg tuples))))))
-
-(mac compile-as-textile (arg)
-     (if (isa 'string arg)
-         (textile-to-html arg)
-         (and (pair? arg)
-              (eq? 'string-pieces (car arg)))
-         `(build-textile-interpolator ,(quotify (cdr arg)))
-         `(list 'textile-to-html ',arg)))
-
-(mac textile-build-function (param-names textile-string)
-     `(fn ,param-names (render-as-textile ,textile-string)))
-
-(mac render-as-textile (arg)
-     (if (isa 'string arg)
-         (textile-to-html arg)
-         (and (pair? arg)
-              (eq? 'string-pieces (car arg)))
-         (build-textile-interpolator (cdr arg))
-         `(textile-to-html ,arg)))