What does HackerNews think of enlive?

SSAX, SXML and SXSLT are available as a package for Racket:

http://pkg-build.racket-lang.org/doc/sxml/

`raco pkg install sxml`[1]

I was recently looking for an enlive[2]-like library to use with a Racket-based project and couldn't find one. Yes, Racket has powerful syntax manipulation and pattern matching[3] built-in, but I wanted functional transforms of X/HTML akin to what enlive gives me in my Clojure-based projects. SXSLT seems to fit the bill quite nicely.

[1] http://docs.racket-lang.org/raco/

[2] https://github.com/cgrand/enlive

[3] http://docs.racket-lang.org/guide/match.html

My favorite library for this:

https://github.com/cgrand/enlive

This is why I love Enlive[1], Enfocus[2] and Kioo[3] (and Enliven[4] is looking awesome too!).

Your logic stays in your code, the templates are snippets of pure HTML. Dynamic content is generated by manipulating and composing the snippets in code. Snippets can be defined in one large HTML file or many files - up to you. The code uses CSS selectors to choose which parts of the HTML to use and transform.

For example, lets say I have a blog application:

    \n        
Welcome to my Blog
\n        
\n            
\n                
My post
\n                
Post content here
\n                
\n                    
A comment
\n                
\n            
\n        
\n    \n

\nThen my code might look something like this:

    (enlive/defsnippet comment-snippet "myfile.html"\n      [:.comments]\n      [comments]\n      [:.comment] (enlive/clone-for [comment comments\n                    (enlivecontent comment))\n\n    (enlive/defsnippet post-snippet "myfile.html"\n      [:#posts]\n      [posts]\n      [:.post] (enlive/clone-for [{:keys [title content comments} posts]\n                 [:.title]    (enlive/content title)\n                 [:.content]  (enlive/content content)\n                 [:.comments] (comment-snippet comments)))\n

\nThat is, parts of snippets are selected and transformed in some way (changing the content, adding/removing css classes or styles, setting attributes, prepending or appending content, wrapping or unwrapping tags, duplicating for each element in a list, etc). This lets you write your page elements as mocked up snippets with dummy data and then merge them together, fill in content, dynamically update attributes and classes all without putting any logic into the HTML.

This also makes it very designer friendly because they can work in pure HTML and CSS without worrying about templating - they only need to make sure to follow your basic structure outline (ie making sure your selectors match the right thing).

[1] https://github.com/cgrand/enlive

[2] https://github.com/ckirkendall/enfocus

[3] https://github.com/ckirkendall/kioo

[4] https://github.com/cgrand/enliven

String templating is not type safe, operational transforms on trees (AST) can be type/structural safe.

Clojure https://github.com/cgrand/enlive

Python https://github.com/supervisor/meld3

> I like even more the idea of being able to have a HTML/CSS/etc expert, who doesn't necessarily know Clojure, be able to maintain the HTML instead of me.

Check out Enlive, it solves exactly this problem. HTML/CSS is separate from Clojure code and you fill out templates and stuff via CSS style selectors. It's sweet.

https://github.com/swannodette/enlive-tutorial

https://github.com/cgrand/enlive

Btw I think you can use Enlive with Noir, even though some of the examples from Noir use Hiccup, it's not a requirement.

Some of my favourites -

* Enlive, a HTML scraping & templating library implemented on top of DOM parsing & state machines https://github.com/cgrand/enlive

* Core Logic, a Prolog-like logic programming library https://github.com/clojure/core.logic

* The ClojureScript compiler, a Clojure compiler that targets JavaScript https://github.com/clojure/clojurescript/blob/master/src/clj...

* Ring, a Rack/WSGI like web-app library https://github.com/mmcgrana/ring

* Midje a very powerful test framework https://github.com/marick/Midje

* Carmine, a Redis client lib in Pure Clojure https://github.com/ptaoussanis/carmine/

[EDIT] Added Midje, Ring.

Regarding Clojure, while compojure is popular, a compojure centric view of web programming is misguided. Compojure is part of a growing ecosystem of libraries built on top of ring[1][2].

Firstly this ecosystem is not analogous to rails or django. The closest is that Compojure is similar to Sinatra i believe.

If you are looking at getting started with web programming in Clojure you need to get familiar with ring (the http abstraction) and look at Compojure and Moustache (routing and handler composition), and Enlive[4] and Hiccup[5] (templating/html generation). Compojure and Moustache are fairly similar, but Enlive and Hiccup are extremely different. A web application will consist of ring plus one of each layer.

As has been mentioned by others in this thread, the depth, breadth and currentness of documentation for these libraries varies. David Nolen has a great tutorial for enlive[6] that i would encourage anyone looking at these libs to work through. Enlive is one of the most compelling aspects of the clojure web ecosystem at present.

These libraries provide the core pieces you would expect to see in any web framework, but a lot of the smaller details are missing. Of note there is no ORM for clojure (for obvious reasons) - If you are looking for a good SQL abstraction you should look at ClojureQL[7] - and aspects such as form generation, validation and processing is still in early days.

My day job has me building web apps with Django. I wouldnt suggest that my coworkers and I jump to clojure / ring et al yet. The breadth of libraries and out of the box stuff in django is still a huge advantage for the day to day rapid web site / web app development, however clojure's story is improving rapidly and i think that the functional model is a particularly good fit for web applications.

I cannot compare clojure's story with the other languages and frameworks mentioned.

  [1] https://github.com/mmcgrana/ring/ 
  [2] This is true of compojure 0.4 and newer. compojure existed prior to ring (with hiccup as part of it).
  [3] https://github.com/cgrand/moustache
  [4] https://github.com/cgrand/enlive
  [5] https://github.com/weavejester/hiccup
  [6] There is a link in the enlive readme
  [7] https://github.com/LauJensen/clojureql/

The Enlive system (for Clojure, see https://github.com/cgrand/enlive) does something very similar.

People using clojure can get selector based scraping using Enlive instead of JQuery [1]. It also ends up doubling as a templating library. I use it for templating on my website and I use it to scrape Hacker News, though that project the scraping is for isn't ready for launch [2].

1: https://github.com/cgrand/enlive

2: https://github.com/jColeChanged/mysite

Or don't template at all. Let your designers design documents, then you write code to modify the markup at key integration points:

https://github.com/cgrand/enlive

This has some really nice properties:

1. The only thing your devs and designers need to agree on is some basic semantic markup and tag IDs. Then they can make a full comp (complete with sample data) for their purposes. You simply rewrite that data.

2. The approach is very declarative, which makes it a lot easier to reason about what is actually being shown and what is actually changing.

3. It's amenable to all the same functional properties of the sexp->xml stuff that you see here.

Enlive's approach is a nearly 100% win for doing site templating over these sorts of sexp->xml libraries.

I still think the new gold standard for functional and extensible HTML templating is Enlive - people should look into this before coming up with variations of the same old wheel - https://github.com/cgrand/enlive