ruby-clean-css 0.0.2

data/lib/javascript/clean-css/lib/selectors/empty-removal.js

@@ -0,0 +1,30 @@
+module.exports = function EmptyRemoval(data) {
+  var stripEmpty = function(cssData) {
+    var tempData = [];
+    var nextEmpty = 0;
+    var cursor = 0;
+
+    for (; nextEmpty < cssData.length;) {
+      nextEmpty = cssData.indexOf('{}', cursor);
+      if (nextEmpty == -1)
+        break;
+
+      var startsAt = nextEmpty - 1;
+      while (cssData[startsAt] && cssData[startsAt] != '}' && cssData[startsAt] != '{' && cssData[startsAt] != ';')
+        startsAt--;
+
+      tempData.push(cssData.substring(cursor, startsAt + 1));
+      cursor = nextEmpty + 2;
+    }
+
+    return tempData.length > 0 ?
+      stripEmpty(tempData.join('') + cssData.substring(cursor, cssData.length)) :
+      cssData;
+  };
+
+  return {
+    process: function() {
+      return stripEmpty(data);
+    }
+  };
+};

data/lib/javascript/clean-css/lib/selectors/optimizer.js

@@ -0,0 +1,341 @@
+var Tokenizer = require('./tokenizer');
+var PropertyOptimizer = require('../properties/optimizer');
+
+module.exports = function Optimizer(data, context, options) {
+  var specialSelectors = {
+    '*': /\-(moz|ms|o|webkit)\-/,
+    'ie8': /(\-moz\-|\-ms\-|\-o\-|\-webkit\-|:root|:nth|:first\-of|:last|:only|:empty|:target|:checked|::selection|:enabled|:disabled|:not)/,
+    'ie7': /(\-moz\-|\-ms\-|\-o\-|\-webkit\-|:focus|:before|:after|:root|:nth|:first\-of|:last|:only|:empty|:target|:checked|::selection|:enabled|:disabled|:not)/
+  };
+
+  var minificationsMade = [];
+
+  var propertyOptimizer = new PropertyOptimizer(options.compatibility, options.aggressiveMerging);
+
+  var cleanUpSelector = function(selectors) {
+    if (selectors.indexOf(',') == -1)
+      return selectors;
+
+    var plain = [];
+    var cursor = 0;
+    var lastComma = 0;
+    var noBrackets = selectors.indexOf('(') == -1;
+    var withinBrackets = function(idx) {
+      if (noBrackets)
+        return false;
+
+      var previousOpening = selectors.lastIndexOf('(', idx);
+      var previousClosing = selectors.lastIndexOf(')', idx);
+
+      if (previousOpening == -1)
+        return false;
+      if (previousClosing > 0 && previousClosing < idx)
+        return false;
+
+      return true;
+    };
+
+    while (true) {
+      var nextComma = selectors.indexOf(',', cursor + 1);
+      var selector;
+
+      if (nextComma === -1) {
+        nextComma = selectors.length;
+      } else if (withinBrackets(nextComma)) {
+        cursor = nextComma + 1;
+        continue;
+      }
+      selector = selectors.substring(lastComma, nextComma);
+      lastComma = cursor = nextComma + 1;
+
+      if (plain.indexOf(selector) == -1)
+        plain.push(selector);
+
+      if (nextComma === selectors.length)
+        break;
+    }
+
+    return plain.sort().join(',');
+  };
+
+  var isSpecial = function(selector) {
+    return specialSelectors[options.compatibility || '*'].test(selector);
+  };
+
+  var removeDuplicates = function(tokens) {
+    var matched = {};
+    var forRemoval = [];
+
+    for (var i = 0, l = tokens.length; i < l; i++) {
+      var token = tokens[i];
+      if (typeof token == 'string' || token.block)
+        continue;
+
+      var id = token.body + '@' + token.selector;
+      var alreadyMatched = matched[id];
+
+      if (alreadyMatched) {
+        forRemoval.push(alreadyMatched[0]);
+        alreadyMatched.unshift(i);
+      } else {
+        matched[id] = [i];
+      }
+    }
+
+    forRemoval = forRemoval.sort(function(a, b) {
+      return a > b ? 1 : -1;
+    });
+
+    for (var j = 0, n = forRemoval.length; j < n; j++) {
+      tokens.splice(forRemoval[j] - j, 1);
+    }
+
+    minificationsMade.unshift(forRemoval.length > 0);
+  };
+
+  var mergeAdjacent = function(tokens) {
+    var forRemoval = [];
+    var lastToken = { selector: null, body: null };
+
+    for (var i = 0, l = tokens.length; i < l; i++) {
+      var token = tokens[i];
+
+      if (typeof token == 'string' || token.block)
+        continue;
+
+      if (token.selector == lastToken.selector) {
+        var joinAt = [lastToken.body.split(';').length];
+        lastToken.body = propertyOptimizer.process(lastToken.body + ';' + token.body, joinAt);
+        forRemoval.push(i);
+      } else if (token.body == lastToken.body && !isSpecial(token.selector) && !isSpecial(lastToken.selector)) {
+        lastToken.selector = cleanUpSelector(lastToken.selector + ',' + token.selector);
+        forRemoval.push(i);
+      } else {
+        lastToken = token;
+      }
+    }
+
+    for (var j = 0, m = forRemoval.length; j < m; j++) {
+      tokens.splice(forRemoval[j] - j, 1);
+    }
+
+    minificationsMade.unshift(forRemoval.length > 0);
+  };
+
+  var reduceNonAdjacent = function(tokens) {
+    var candidates = {};
+    var moreThanOnce = [];
+
+    for (var i = tokens.length - 1; i >= 0; i--) {
+      var token = tokens[i];
+
+      if (typeof token == 'string' || token.block)
+        continue;
+
+      var complexSelector = token.selector;
+      var selectors = complexSelector.indexOf(',') > -1 && !isSpecial(complexSelector) ?
+        complexSelector.split(',').concat(complexSelector) : // simplification, as :not() can have commas too
+        [complexSelector];
+
+      for (var j = 0, m = selectors.length; j < m; j++) {
+        var selector = selectors[j];
+
+        if (!candidates[selector])
+          candidates[selector] = [];
+        else
+          moreThanOnce.push(selector);
+
+        candidates[selector].push({
+          where: i,
+          partial: selector != complexSelector
+        });
+      }
+    }
+
+    var reducedInSimple = _reduceSimpleNonAdjacentCases(tokens, moreThanOnce, candidates);
+    var reducedInComplex = _reduceComplexNonAdjacentCases(tokens, candidates);
+
+    minificationsMade.unshift(reducedInSimple || reducedInComplex);
+  };
+
+  var _reduceSimpleNonAdjacentCases = function(tokens, matches, positions) {
+    var reduced = false;
+
+    for (var i = 0, l = matches.length; i < l; i++) {
+      var selector = matches[i];
+      var data = positions[selector];
+
+      if (data.length < 2)
+        continue;
+
+      /* jshint loopfunc: true */
+      _reduceSelector(tokens, selector, data, {
+        filterOut: function(idx, bodies) {
+          return data[idx].partial && bodies.length === 0;
+        },
+        callback: function(token, newBody, processedCount, tokenIdx) {
+          if (!data[processedCount - tokenIdx - 1].partial) {
+            token.body = newBody.join(';');
+            reduced = true;
+          }
+        }
+      });
+    }
+
+    return reduced;
+  };
+
+  var _reduceComplexNonAdjacentCases = function(tokens, positions) {
+    var reduced = false;
+
+    allSelectors:
+    for (var complexSelector in positions) {
+      if (complexSelector.indexOf(',') == -1) // simplification, as :not() can have commas too
+        continue;
+
+      var intoPosition = positions[complexSelector].pop().where;
+      var intoToken = tokens[intoPosition];
+
+      var selectors = isSpecial(complexSelector) ?
+        [complexSelector] :
+        complexSelector.split(',');
+      var reducedBodies = [];
+
+      for (var j = 0, m = selectors.length; j < m; j++) {
+        var selector = selectors[j];
+        var data = positions[selector];
+
+        if (data.length < 2)
+          continue allSelectors;
+
+        /* jshint loopfunc: true */
+        _reduceSelector(tokens, selector, data, {
+          filterOut: function(idx) {
+            return data[idx].where < intoPosition;
+          },
+          callback: function(token, newBody, processedCount, tokenIdx) {
+            if (tokenIdx === 0)
+              reducedBodies.push(newBody.join(';'));
+          }
+        });
+
+        if (reducedBodies[reducedBodies.length - 1] != reducedBodies[0])
+          continue allSelectors;
+      }
+
+      intoToken.body = reducedBodies[0];
+      reduced = true;
+    }
+
+    return reduced;
+  };
+
+  var _reduceSelector = function(tokens, selector, data, options) {
+    var bodies = [];
+    var joinsAt = [];
+    var splitBodies = [];
+    var processedTokens = [];
+
+    for (var j = data.length - 1, m = 0; j >= 0; j--) {
+      if (options.filterOut(j, bodies))
+        continue;
+
+      var where = data[j].where;
+      var token = tokens[where];
+      var body = token.body;
+      bodies.push(body);
+      splitBodies.push(body.split(';'));
+      processedTokens.push(where);
+    }
+
+    for (j = 0, m = bodies.length; j < m; j++) {
+      if (bodies[j].length > 0)
+        joinsAt.push((joinsAt[j - 1] || 0) + splitBodies[j].length);
+    }
+
+    var optimizedBody = propertyOptimizer.process(bodies.join(';'), joinsAt, true);
+    var optimizedProperties = optimizedBody.split(';');
+
+    var processedCount = processedTokens.length;
+    var propertyIdx = optimizedProperties.length - 1;
+    var tokenIdx = processedCount - 1;
+
+    while (tokenIdx >= 0) {
+      if ((tokenIdx === 0 || splitBodies[tokenIdx].indexOf(optimizedProperties[propertyIdx]) > -1) && propertyIdx > -1) {
+        propertyIdx--;
+        continue;
+      }
+
+      var newBody = optimizedProperties.splice(propertyIdx + 1);
+      options.callback(tokens[processedTokens[tokenIdx]], newBody, processedCount, tokenIdx);
+
+      tokenIdx--;
+    }
+  };
+
+  var optimize = function(tokens) {
+    var noChanges = function() {
+      return minificationsMade.length > 4 &&
+        minificationsMade[0] === false &&
+        minificationsMade[1] === false;
+    };
+
+    tokens = Array.isArray(tokens) ? tokens : [tokens];
+    for (var i = 0, l = tokens.length; i < l; i++) {
+      var token = tokens[i];
+
+      if (token.selector) {
+        token.selector = cleanUpSelector(token.selector);
+        token.body = propertyOptimizer.process(token.body, false);
+      } else if (token.block) {
+        optimize(token.body);
+      }
+    }
+
+    // Run until 2 last operations do not yield any changes
+    minificationsMade = [];
+    while (true) {
+      if (noChanges())
+        break;
+      removeDuplicates(tokens);
+
+      if (noChanges())
+        break;
+      mergeAdjacent(tokens);
+
+      if (noChanges())
+        break;
+      reduceNonAdjacent(tokens);
+    }
+  };
+
+  var rebuild = function(tokens) {
+    var rebuilt = [];
+
+    tokens = Array.isArray(tokens) ? tokens : [tokens];
+    for (var i = 0, l = tokens.length; i < l; i++) {
+      var token = tokens[i];
+
+      if (typeof token == 'string') {
+        rebuilt.push(token);
+        continue;
+      }
+
+      var name = token.block || token.selector;
+      var body = token.block ? rebuild(token.body) : token.body;
+
+      if (body.length > 0)
+        rebuilt.push(name + '{' + body + '}');
+    }
+
+    return rebuilt.join(options.keepBreaks ? options.lineBreak : '');
+  };
+
+  return {
+    process: function() {
+      var tokenized = new Tokenizer(data, context).process();
+      optimize(tokenized);
+      return rebuild(tokenized);
+    }
+  };
+};

data/lib/javascript/clean-css/lib/selectors/tokenizer.js

@@ -0,0 +1,168 @@
+module.exports = function Tokenizer(data, minifyContext) {
+  var chunker = new Chunker(data, 128);
+  var chunk = chunker.next();
+  var flatBlock = /(^@(font\-face|page|\-ms\-viewport|\-o\-viewport|viewport)|\\@.+?)/;
+
+  var whatsNext = function(context) {
+    var cursor = context.cursor;
+    var mode = context.mode;
+    var closest;
+
+    if (chunk.length == context.cursor) {
+      if (chunker.isEmpty())
+        return null;
+
+      chunk = chunker.next();
+      context.cursor = 0;
+    }
+
+    if (mode == 'body') {
+      closest = chunk.indexOf('}', cursor);
+      return closest > -1 ?
+        [closest, 'bodyEnd'] :
+        null;
+    }
+
+    var nextSpecial = chunk.indexOf('@', context.cursor);
+    var nextEscape = mode == 'top' ? chunk.indexOf('__ESCAPED_COMMENT_CLEAN_CSS', context.cursor) : -1;
+    var nextBodyStart = chunk.indexOf('{', context.cursor);
+    var nextBodyEnd = chunk.indexOf('}', context.cursor);
+
+    closest = nextSpecial;
+    if (closest == -1 || (nextEscape > -1 && nextEscape < closest))
+      closest = nextEscape;
+    if (closest == -1 || (nextBodyStart > -1 && nextBodyStart < closest))
+      closest = nextBodyStart;
+    if (closest == -1 || (nextBodyEnd > -1 && nextBodyEnd < closest))
+      closest = nextBodyEnd;
+
+    if (closest == -1)
+      return;
+    if (nextEscape === closest)
+      return [closest, 'escape'];
+    if (nextBodyStart === closest)
+      return [closest, 'bodyStart'];
+    if (nextBodyEnd === closest)
+      return [closest, 'bodyEnd'];
+    if (nextSpecial === closest)
+      return [closest, 'special'];
+  };
+
+  var tokenize = function(context) {
+    var tokenized = [];
+
+    context = context || { cursor: 0, mode: 'top' };
+
+    while (true) {
+      var next = whatsNext(context);
+      if (!next) {
+        var whatsLeft = chunk.substring(context.cursor);
+        if (whatsLeft.length > 0) {
+          tokenized.push(whatsLeft);
+          context.cursor += whatsLeft.length;
+        }
+        break;
+      }
+
+      var nextSpecial = next[0];
+      var what = next[1];
+      var nextEnd;
+      var oldMode;
+
+      if (what == 'special') {
+        var firstOpenBraceAt = chunk.indexOf('{', nextSpecial);
+        var firstSemicolonAt = chunk.indexOf(';', nextSpecial);
+        var isSingle = firstSemicolonAt > -1 && (firstOpenBraceAt == -1 || firstSemicolonAt < firstOpenBraceAt);
+        if (isSingle) {
+          nextEnd = chunk.indexOf(';', nextSpecial + 1);
+          tokenized.push(chunk.substring(context.cursor, nextEnd + 1));
+
+          context.cursor = nextEnd + 1;
+        } else {
+          nextEnd = chunk.indexOf('{', nextSpecial + 1);
+          var block = chunk.substring(context.cursor, nextEnd).trim();
+
+          var isFlat = flatBlock.test(block);
+          oldMode = context.mode;
+          context.cursor = nextEnd + 1;
+          context.mode = isFlat ? 'body' : 'block';
+          var specialBody = tokenize(context);
+          context.mode = oldMode;
+
+          tokenized.push({ block: block, body: specialBody });
+        }
+      } else if (what == 'escape') {
+        nextEnd = chunk.indexOf('__', nextSpecial + 1);
+        var escaped = chunk.substring(context.cursor, nextEnd + 2);
+        tokenized.push(escaped);
+
+        context.cursor = nextEnd + 2;
+      } else if (what == 'bodyStart') {
+        var selector = chunk.substring(context.cursor, nextSpecial).trim();
+
+        oldMode = context.mode;
+        context.cursor = nextSpecial + 1;
+        context.mode = 'body';
+        var body = tokenize(context);
+        context.mode = oldMode;
+
+        tokenized.push({ selector: selector, body: body });
+      } else if (what == 'bodyEnd') {
+        // extra closing brace at the top level can be safely ignored
+        if (context.mode == 'top') {
+          var at = context.cursor;
+          var warning = chunk[context.cursor] == '}' ?
+            'Unexpected \'}\' in \'' + chunk.substring(at - 20, at + 20) + '\'. Ignoring.' :
+            'Unexpected content: \'' + chunk.substring(at, nextSpecial + 1) + '\'. Ignoring.';
+
+          minifyContext.warnings.push(warning);
+          context.cursor = nextSpecial + 1;
+          continue;
+        }
+
+        if (context.mode != 'block')
+          tokenized = chunk.substring(context.cursor, nextSpecial);
+
+        context.cursor = nextSpecial + 1;
+
+        break;
+      }
+    }
+
+    return tokenized;
+  };
+
+  return {
+    process: function() {
+      return tokenize();
+    }
+  };
+};
+
+// Divides `data` into chunks of `chunkSize` for faster processing
+var Chunker = function(data, chunkSize) {
+  var chunks = [];
+  for (var cursor = 0, dataSize = data.length; cursor < dataSize;) {
+    var nextCursor = cursor + chunkSize > dataSize ?
+      dataSize - 1 :
+      cursor + chunkSize;
+
+    if (data[nextCursor] != '}')
+      nextCursor = data.indexOf('}', nextCursor);
+    if (nextCursor == -1)
+      nextCursor = data.length - 1;
+
+    chunks.push(data.substring(cursor, nextCursor + 1));
+    cursor = nextCursor + 1;
+  }
+
+  return {
+    isEmpty: function() {
+      return chunks.length === 0;
+    },
+
+    next: function() {
+      return chunks.shift() || '';
+    }
+  };
+};