Began making a non-PhantomJS version

Author: spookd

lib/domino-chains/extract.coffee

@@ -0,0 +1,139 @@
+async    = require("async")
+request  = require("request")
+css      = require("css")
+CleanCSS = require("clean-css")
+_        = require("lodash")
+url      = require("url")
+
+getElementAttributes = (el, ignore...) ->
+  attrs = {}
+
+  for attr of el.attributes when typeof el.attributes[attr] is "object" and typeof el.attributes[attr].data is "string"
+    continue if ignore.indexOf(attr) isnt -1
+    attrs[attr] = el.attributes[attr].data
+
+  return attrs
+
+module.exports = exports =
+  extractStylesheets: (window, document, options, next) ->
+    options.cout "Extracting stylesheets"
+    links  = document.querySelectorAll("link[rel='stylesheet']")
+    sheets = []
+
+    for link in links
+      attrs = getElementAttributes(link, "media", "rel")
+      continue unless typeof attrs.href is "string"
+
+      # Domino bug/incorrect usage?
+      realHref = attrs.href
+
+      delete attrs.href
+
+      sheets.push
+        href:        url.resolve(options.url, realHref)
+        media:       link.media
+        attributes:  attrs
+
+    urlParsed = url.parse(options.url)
+
+    sheets = sheets.filter (sheet) ->
+      _.every options.ignoreSheets, (ignore) ->
+        if ignore instanceof RegExp and ignore.test(sheet.href)
+          options.cout "|> Ignoring stylesheet (#{sheet.href}) because of ignore-rule #{ignore.toString()}"
+          return no
+
+        return sheet.href isnt ignore
+
+      if options.ignoreExternalSheets
+        if urlParsed.hostname isnt url.parse(sheet.href).hostname
+          options.cout "|> Ignoring stylesheet (#{sheet.href}) because external stylesheets are ignored"
+          return no
+        
+        return true
+
+    sheets = sheets.filter((sheet) -> return media.indexOf(sheet.media) isnt -1)
+
+    next(null, sheets)
+
+  downloadStylesheets: (window, document, options, sheets, next) ->
+    if not sheets or sheets.length is 0
+      options.cout "Refusing to continue: 0 stylesheets"
+      return next("Refusing to continue: 0 stylesheets")
+
+    options.cout "Downloading #{sheets.length} stylesheet(s)"
+
+    mapFn = (sheet, done) ->
+      requestOptions =
+        headers:
+          "User-Agent": options.userAgent
+
+      request sheet.href, requestOptions, (error, response, body) ->
+        if error
+          options.cout "Failed to download stylesheet #{sheet.href}: #{error.toString()}"
+        else if response.statusCode < 200 or response.statusCode > 399
+          options.cout "Failed to download stylesheet #{sheet.href}: Status code not in valid range #{response.statusCode.toString()}"
+        else
+          options.cout "|> Stylesheet downloaded: #{sheet.href}"
+
+        body = "" if not error and (response.statusCode < 200 or response.statusCode > 399)
+
+        # Rebase url()'s
+        body = body.replace /url\((["']|)([^"'\(\)]+)\1\)/g, (m, quote, uri) ->
+          return "url(#{quote}#{url.resolve(sheet.href, uri)}#{quote})"
+
+        sheet.body = body
+
+        done(error, sheet)
+
+    async.map(sheets, mapFn, next)
+
+  parseStylesheets: (window, document, options, sheets, next) ->
+    if sheets
+      cssString = ""
+
+      for sheet in sheets
+        cssString += sheet.body
+
+      options.cout "Parsing #{sheets.length} stylesheet(s) - #{cssString.split("\n").length} lines"
+
+      try
+        styles = css.parse(cssString).stylesheet
+      catch e
+        if e.line
+          line = cssString.split("\n")[e.line - 1]
+          line = line.substring(e.column - 40, e.column) if line.length > 40 and e.column
+          e.message = "node-css-inliner: #{e.message}\n\t -> #{line.substring(0, 40)}"
+
+        return next(e)
+      
+      next(null, sheets, styles)
+    else
+      next("Failed to download stylesheets")
+
+  filter: (window, document, options, sheets, styles, next) ->
+    options.cout "Starting to filter out rules ..."
+
+    filterChain = require("./filter")
+    
+    for action of filterChain
+      filterChain[action] = filterChain[action].bind(null, document, options, styles)
+
+    async.waterfall _.toArray(filterChain), (error, usedStyles) ->
+      next(error, sheets, styles, usedStyles)
+
+  generateStyles: (window, document, options, sheets, styles, usedStyles, next) ->
+    try
+      finalCSS = css.stringify(stylesheet: rules: usedStyles)
+
+      if options.cssMinify isnt no
+        finalCSS = new CleanCSS(if typeof options.cssMinify is "object" then options.cssMinify else {}).minify(finalCSS)
+
+      sheets = sheets.filter (sheet) ->
+        delete sheet["body"]
+        return yes
+
+      next(null, sheets, finalCSS)
+    catch e
+      next(error)
+    
+

lib/domino-chains/filter.coffee

@@ -0,0 +1,87 @@
+async   = require("async")
+css     = require("css")
+_       = require("lodash")
+
+dePseudify = (->
+  ignoredPseudos = [
+    #/* link */
+    ':link', ':visited',
+    #/* user action */
+    ':hover', ':active', ':focus',
+    #/* UI element states */
+    ':enabled', ':disabled', ':checked', ':indeterminate',
+    #/* pseudo elements */
+    '::first-line', '::first-letter', '::selection', '::before', '::after',
+    #/* CSS2 pseudo elements */
+    ':before', ':after'
+  ]
+
+  regex = new RegExp(ignoredPseudos.join('|'), 'g');
+
+  return (selector) ->
+    return selector.replace(regex, "")
+)()
+
+module.exports = exports =
+  findSelectorsUsed: (document, options, styles, next, test) ->
+    options.cout "|> Finding selectors used", test
+
+    filterUsed = (rules, cb, recursive = no) ->
+      concatFn = (rule, done) ->
+        if rule.type is "rule"
+          return done(null, rule.selectors)
+        else if rule.type is "media"
+          return filterUsed(rule.rules, done, yes)
+
+        return done(null, [])
+
+      filterFn = (error, selectors) ->
+        return cb(error, selectors) if recursive
+
+        selectors = selectors.filter (selector) ->
+          try
+            return yes if document.querySelector(selector)
+          catch e
+            return yes
+
+        cb(null, selectors)
+
+      return async.concat(rules, concatFn, filterFn)
+
+    filterUsed styles.rules, (error, usedSelectors) ->
+      next(null, usedSelectors)
+
+  removeUnusedRules: (document, options, styles, usedSelectors, next) ->
+    options.cout "|> Removing unused selectors"
+    selectorsToIgnore = options.ignoreSelectors
+
+    filterEmptyRules = (rules) ->
+      return rules.filter (rule) ->
+        return rule.selectors.length isnt 0 if rule.type is "rule"
+
+        if rule.type is "media"
+          rule.rules = filterEmptyRules(rule.rules)
+          return rule.rules.length isnt 0
+
+        return yes
+
+    filterSelectors = (selectors) ->
+      return selectors.filter (selector) ->
+        return yes if selector[0] is "@"
+
+        for ignoreRule in selectorsToIgnore
+          return ignoreRule.test(selector) if ignoreRule instanceof RegExp
+          return yes if ignoreRule is selector
+
+        return usedSelectors.indexOf(selector) isnt -1
+
+    filterRules = (rules) ->
+      for rule in rules
+        if rule.type is "rule"
+          rule.selectors = filterSelectors(rule.selectors)
+        else if rule.type is "media"
+          rule.rules = filterRules(rule.rules)
+
+      return filterEmptyRules(rules)
+
+    next(null, filterRules(styles.rules))

lib/domino-chains/return.coffee

@@ -0,0 +1,39 @@
+module.exports = exports =
+  exposeStylesheets: (document, options, sheets, finalCSS, next) ->
+    return next(null) if not options.cssExpose or typeof options.cssExpose isnt "string"
+
+    name = options.cssExpose
+    
+    script = document.createElement("script")
+    script.innerHTML = "#{name} = #{JSON.stringify(stylesheets)};"
+    script.innerHTML = "var " + script.innerHTML if name.indexOf(".") < 0
+    document.getElementsByTagName("body")[0].appendChild(script)
+
+    next(null)
+
+  removeStylesheetsAndInjectUsedStyles: (document, options, sheets, finalCSS, next) ->
+    links = document.querySelectorAll("link[rel='stylesheet']")
+    linkForHref = (href) ->
+      for link in links
+        return link if link.href is href
+
+    for sheet in sheets
+      el = linkForHref(sheet.href)
+      continue unless el
+
+      if first?
+        el.parentNode.removeChild(el)
+      else
+        first = el
+
+    style = document.createElement("style")
+    style.setAttribute("type", "text/css")
+    style.setAttribute("id", options.cssId) if options.cssId? and typeof options.cssId is "string"
+    style.innerHTML = finalCSS
+
+    if first?
+      first.parentNode.replaceChild(style, first)
+    else
+      document.getElementsByTagName("head")[0].appendChild(style)
+    
+    next(null, document.documentElement.outerHTML)

lib/inliner.coffee

@@ -1,9 +1,8 @@
 async    = require("async")
 _        = require("underscore")
 Phantom  = require("./phantom")
-
-extractChain = require("./chains/extract")
-returnChain  = require("./chains/return")
+domino   = require("domino")
+request  = require("request")
 
 defaultOptions =
   # Core
@@ -16,9 +15,14 @@ defaultOptions =
   cssId:           no
   cssExpose:       no
 
+  # Experimental
+  useDomino:       no
+
   # Miscellaneous
   ignoreSheets:    []
   ignoreSelectors: []
+  # ...
+  userAgent:       "CSS Inliner for node.js by Nicolai Persson"
 
 module.exports = exports = (options = {}, cb) ->
   options = _.extend(defaultOptions, options)
@@ -27,39 +31,73 @@ module.exports = exports = (options = {}, cb) ->
     cb("The URL option is required both for 'faking' (i.e. for providing the HTML) and loading an actual website")
     return
 
-  # Aquire a PhantomJS instance from our pool
-  Phantom.acquire (error, ph) ->
-    if error
-      Phantom.release(ph)
-      cb(error)
-      return
-
-    # Create a page
-    ph.createPage (error, page) ->
-      origCb = cb
-      cb     = (e, cssOrHtml) ->
-        page.close()
+  if options.log
+    console.log "Inlining #{options.url}", if options.html then "(fake URL with content)" else "" 
+
+  options.cout = (args...) ->
+    console.log "──", args.join(" ") if options.log
+
+  if not options.useDomino
+    # Aquire a PhantomJS instance from our pool
+    Phantom.acquire (error, ph) ->
+      if error
         Phantom.release(ph)
-        origCb(e, cssOrHtml)
+        cb(error)
+        return
+
+      # Create a page
+      ph.createPage (error, page) ->
+        origCb = cb
+        cb     = (e, cssOrHtml) ->
+          page.close()
+          Phantom.release(ph)
+          origCb(e, cssOrHtml)
 
-      return cb(error) if error
+        return cb(error) if error
 
-      if options.log
-        console.log "Inlining #{options.url}", if options.html then "(fake URL with content)" else "" 
+        extractChain = require("./phantom-chains/extract")
+        for action of extractChain
+          extractChain[action] = extractChain[action].bind(null, page, options)
 
-      options.cout = (args...) ->
-        console.log "──", args.join(" ") if options.log
+        async.waterfall _.toArray(extractChain), (error, stylesheets, finalCSS) ->
+          return cb(error) if error
 
+          if options.cssOnly
+            cb(null, usedCss)
+          else
+            returnChain = require("./phantom-chains/return")
+
+            for action of returnChain
+              returnChain[action] = returnChain[action].bind(null, page, options, stylesheets, finalCSS)
+            
+            async.waterfall _.toArray(returnChain), cb
+  else
+    proceed = (html) ->
+      window   = domino.createWindow(html)
+      document = window.document
+
+      window.location.href = options.url
+      
+      extractChain = require("./domino-chains/extract")
       for action of extractChain
-        extractChain[action] = extractChain[action].bind(null, page, options)
+        extractChain[action] = extractChain[action].bind(null, window, document, options)
 
       async.waterfall _.toArray(extractChain), (error, stylesheets, finalCSS) ->
         return cb(error) if error
 
         if options.cssOnly
           cb(null, usedCss)
         else
+          returnChain = require("./domino-chains/return")
+
           for action of returnChain
-            returnChain[action] = returnChain[action].bind(null, page, options, stylesheets, finalCSS)
+            returnChain[action] = returnChain[action].bind(null, document, options, stylesheets, finalCSS)
 
           async.waterfall _.toArray(returnChain), cb
+
+    if not options.html
+      request options.url, "User-Agent": options.userAgent, (error, response, body) ->
+        return cb(error) if error
+        proceed(body)
+    else
+      proceed(options.html)