ruby-clean-css 0.0.2

data/lib/javascript/clean-css/lib/text/comments.js

@@ -0,0 +1,83 @@
+var EscapeStore = require('./escape-store');
+var QuoteScanner = require('./quote-scanner');
+
+module.exports = function Comments(keepSpecialComments, keepBreaks, lineBreak) {
+  var comments = new EscapeStore('COMMENT');
+
+  return {
+    // Strip special comments (/*! ... */) by replacing them by a special marker
+    // for further restoring. Plain comments are removed. It's done by scanning data using
+    // String#indexOf scanning instead of regexps to speed up the process.
+    escape: function(data) {
+      var tempData = [];
+      var nextStart = 0;
+      var nextEnd = 0;
+      var cursor = 0;
+      var isQuotedAt = (function () {
+        var quoteMap = [];
+        new QuoteScanner(data).each(function (quotedString, _, startsAt) {
+          quoteMap.push([startsAt, startsAt + quotedString.length]);
+        });
+
+        return function (position) {
+          for (var i = 0, l = quoteMap.length; i < l; i++) {
+            if (quoteMap[i][0] < position && quoteMap[i][1] > position)
+              return true;
+          }
+
+          return false;
+        };
+      })();
+
+      for (; nextEnd < data.length;) {
+        nextStart = data.indexOf('/*', cursor);
+        if (nextStart == -1)
+          break;
+        if (isQuotedAt(nextStart)) {
+          tempData.push(data.substring(cursor, nextStart + 2));
+          cursor = nextStart + 2;
+          continue;
+        }
+
+        nextEnd = data.indexOf('*/', nextStart + 2);
+        if (nextEnd == -1)
+          break;
+
+        tempData.push(data.substring(cursor, nextStart));
+        if (data[nextStart + 2] == '!') {
+          // in case of special comments, replace them with a placeholder
+          var comment = data.substring(nextStart, nextEnd + 2);
+          var placeholder = comments.store(comment);
+          tempData.push(placeholder);
+        }
+        cursor = nextEnd + 2;
+      }
+
+      return tempData.length > 0 ?
+        tempData.join('') + data.substring(cursor, data.length) :
+        data;
+    },
+
+    restore: function(data) {
+      var restored = 0;
+      var breakSuffix = keepBreaks ? lineBreak : '';
+
+      return data.replace(new RegExp(comments.placeholderPattern + '(' + lineBreak + '| )?', 'g'), function(match, placeholder) {
+        restored++;
+
+        switch (keepSpecialComments) {
+          case '*':
+            return comments.restore(placeholder) + breakSuffix;
+          case 1:
+          case '1':
+            return restored == 1 ?
+              comments.restore(placeholder) + breakSuffix :
+              '';
+          case 0:
+          case '0':
+            return '';
+        }
+      });
+    }
+  };
+};

data/lib/javascript/clean-css/lib/text/escape-store.js

@@ -0,0 +1,32 @@
+module.exports = function EscapeStore(placeholderRoot) {
+  placeholderRoot = 'ESCAPED_' + placeholderRoot + '_CLEAN_CSS';
+
+  var placeholderToData = {};
+  var dataToPlaceholder = {};
+  var count = 0;
+  var nextPlaceholder = function() {
+    return '__' + placeholderRoot + (count++) + '__';
+  };
+  var pattern = '(__' + placeholderRoot + '\\d{1,}__)';
+
+  return {
+    placeholderPattern: pattern,
+
+    placeholderRegExp: new RegExp(pattern, 'g'),
+
+    store: function(data) {
+      var placeholder = dataToPlaceholder[data];
+      if (!placeholder) {
+        placeholder = nextPlaceholder();
+        placeholderToData[placeholder] = data;
+        dataToPlaceholder[data] = placeholder;
+      }
+
+      return placeholder;
+    },
+
+    restore: function(placeholder) {
+      return placeholderToData[placeholder];
+    }
+  };
+};

data/lib/javascript/clean-css/lib/text/expressions.js

@@ -0,0 +1,73 @@
+var EscapeStore = require('./escape-store');
+
+module.exports = function Expressions() {
+  var expressions = new EscapeStore('EXPRESSION');
+
+  var findEnd = function(data, start) {
+    var end = start + 'expression'.length;
+    var level = 0;
+    var quoted = false;
+
+    while (true) {
+      var next = data[end++];
+
+      if (quoted) {
+        quoted = next != '\'' && next != '"';
+      } else {
+        quoted = next == '\'' || next == '"';
+
+        if (next == '(')
+          level++;
+        if (next == ')')
+          level--;
+        if (next == '}' && level == 1) {
+          end--;
+          level--;
+        }
+      }
+
+      if (level === 0 && next == ')')
+        break;
+      if (!next) {
+        end = data.substring(0, end).lastIndexOf('}');
+        break;
+      }
+    }
+
+    return end;
+  };
+
+  return {
+    // Escapes expressions by replacing them by a special
+    // marker for further restoring. It's done via string scanning
+    // instead of regexps to speed up the process.
+    escape: function(data) {
+      var nextStart = 0;
+      var nextEnd = 0;
+      var cursor = 0;
+      var tempData = [];
+
+      for (; nextEnd < data.length;) {
+        nextStart = data.indexOf('expression(', nextEnd);
+        if (nextStart == -1)
+          break;
+
+        nextEnd = findEnd(data, nextStart);
+
+        var expression = data.substring(nextStart, nextEnd);
+        var placeholder = expressions.store(expression);
+        tempData.push(data.substring(cursor, nextStart));
+        tempData.push(placeholder);
+        cursor = nextEnd;
+      }
+
+      return tempData.length > 0 ?
+        tempData.join('') + data.substring(cursor, data.length) :
+        data;
+    },
+
+    restore: function(data) {
+      return data.replace(expressions.placeholderRegExp, expressions.restore);
+    }
+  };
+};

data/lib/javascript/clean-css/lib/text/free.js

@@ -0,0 +1,26 @@
+(function() {
+  var EscapeStore = require('./escape-store');
+  var QuoteScanner = require('./quote-scanner');
+
+  var Free = function Free() {
+    this.matches = new EscapeStore('FREE_TEXT');
+  };
+
+  // Strip content tags by replacing them by the a special
+  // marker for further restoring. It's done via string scanning
+  // instead of regexps to speed up the process.
+  Free.prototype.escape = function(data) {
+    var self = this;
+
+    return new QuoteScanner(data).each(function(match, store) {
+      var placeholder = self.matches.store(match);
+      store.push(placeholder);
+    });
+  };
+
+  Free.prototype.restore = function(data) {
+    return data.replace(this.matches.placeholderRegExp, this.matches.restore);
+  };
+
+  module.exports = Free;
+})();

data/lib/javascript/clean-css/lib/text/name-quotes.js

@@ -0,0 +1,37 @@
+(function() {
+  var QuoteScanner = require('./quote-scanner');
+  var PropertyScanner = require('../properties/scanner');
+
+  var NameQuotes = function NameQuotes() {};
+
+  var STRIPPABLE = /^['"][a-zA-Z][a-zA-Z\d\-_]+['"]$/;
+
+  var properties = [
+    'animation',
+    '-moz-animation',
+    '-o-animation',
+    '-webkit-animation',
+    'animation-name',
+    '-moz-animation-name',
+    '-o-animation-name',
+    '-webkit-animation-name',
+    'font',
+    'font-family'
+  ];
+
+  NameQuotes.prototype.process = function(data) {
+    var scanner = new PropertyScanner(data);
+
+    return new QuoteScanner(data).each(function(match, store, cursor) {
+      var lastProperty = scanner.nextAt(cursor);
+      if (properties.indexOf(lastProperty) > -1) {
+        if (STRIPPABLE.test(match))
+          match = match.substring(1, match.length - 1);
+      }
+
+      store.push(match);
+    });
+  };
+
+  module.exports = NameQuotes;
+})();

data/lib/javascript/clean-css/lib/text/quote-scanner.js

@@ -0,0 +1,91 @@
+(function() {
+  var QuoteScanner = function QuoteScanner(data) {
+    this.data = data;
+  };
+
+  var findQuoteEnd = function(data, matched, cursor, oldCursor) {
+    var commentStartMark = '/*';
+    var commentEndMark = '*/';
+    var escapeMark = '\\';
+    var blockEndMark = '}';
+    var dataPrefix = data.substring(oldCursor, cursor);
+    var commentEndedAt = dataPrefix.lastIndexOf(commentEndMark, cursor);
+    var commentStartedAt = dataPrefix.lastIndexOf(commentStartMark, cursor);
+    var commentStarted = false;
+
+    if (commentEndedAt >= cursor && commentStartedAt > -1)
+      commentStarted = true;
+    if (commentStartedAt < cursor && commentStartedAt > commentEndedAt)
+      commentStarted = true;
+
+    if (commentStarted) {
+      var commentEndsAt = data.indexOf(commentEndMark, cursor);
+      if (commentEndsAt > -1)
+        return commentEndsAt;
+
+      commentEndsAt = data.indexOf(blockEndMark, cursor);
+      return commentEndsAt > -1 ? commentEndsAt - 1 : data.length;
+    }
+
+    while (true) {
+      if (data[cursor] === undefined)
+        break;
+      if (data[cursor] == matched && data[cursor - 1] != escapeMark)
+        break;
+
+      cursor++;
+    }
+
+    return cursor;
+  };
+
+  QuoteScanner.prototype.each = function(callback) {
+    var data = this.data;
+    var tempData = [];
+    var nextStart = 0;
+    var nextEnd = 0;
+    var cursor = 0;
+    var matchedMark = null;
+    var singleMark = '\'';
+    var doubleMark = '"';
+    var dataLength = data.length;
+
+    for (; nextEnd < data.length;) {
+      var nextStartSingle = data.indexOf(singleMark, nextEnd + 1);
+      var nextStartDouble = data.indexOf(doubleMark, nextEnd + 1);
+
+      if (nextStartSingle == -1)
+        nextStartSingle = dataLength;
+      if (nextStartDouble == -1)
+        nextStartDouble = dataLength;
+
+      if (nextStartSingle < nextStartDouble) {
+        nextStart = nextStartSingle;
+        matchedMark = singleMark;
+      } else {
+        nextStart = nextStartDouble;
+        matchedMark = doubleMark;
+      }
+
+      if (nextStart == -1)
+        break;
+
+      nextEnd = findQuoteEnd(data, matchedMark, nextStart + 1, cursor);
+      if (nextEnd == -1)
+        break;
+
+      var text = data.substring(nextStart, nextEnd + 1);
+      tempData.push(data.substring(cursor, nextStart));
+      if (text.length > 0)
+        callback(text, tempData, nextStart);
+
+      cursor = nextEnd + 1;
+    }
+
+    return tempData.length > 0 ?
+      tempData.join('') + data.substring(cursor, data.length) :
+      data;
+  };
+
+  module.exports = QuoteScanner;
+})();

data/lib/javascript/clean-css/lib/text/splitter.js

@@ -0,0 +1,35 @@
+var Splitter = function Splitter (separator) {
+  this.separator = separator;
+};
+
+Splitter.prototype.split = function (value) {
+  if (value.indexOf(this.separator) === -1)
+    return [value];
+
+  if (value.indexOf('(') === -1)
+    return value.split(this.separator);
+
+  var level = 0;
+  var cursor = 0;
+  var lastStart = 0;
+  var len = value.length;
+  var tokens = [];
+
+  while (cursor++ < len) {
+    if (value[cursor] == '(') {
+      level++;
+    } else if (value[cursor] == ')') {
+      level--;
+    } else if (value[cursor] == this.separator && level === 0) {
+      tokens.push(value.substring(lastStart, cursor));
+      lastStart = cursor + 1;
+    }
+  }
+
+  if (lastStart < cursor + 1)
+    tokens.push(value.substring(lastStart));
+
+  return tokens;
+};
+
+module.exports = Splitter;

data/lib/javascript/clean-css/lib/text/urls.js

@@ -0,0 +1,41 @@
+var EscapeStore = require('./escape-store');
+
+module.exports = function Urls() {
+  var urls = new EscapeStore('URL');
+
+  return {
+    // Strip urls by replacing them by a special
+    // marker for further restoring. It's done via string scanning
+    // instead of regexps to speed up the process.
+    escape: function(data) {
+      var nextStart = 0;
+      var nextEnd = 0;
+      var cursor = 0;
+      var tempData = [];
+
+      for (; nextEnd < data.length;) {
+        nextStart = data.indexOf('url(', nextEnd);
+        if (nextStart == -1)
+          break;
+
+        nextEnd = data.indexOf(')', nextStart);
+
+        var url = data.substring(nextStart, nextEnd + 1);
+        var placeholder = urls.store(url);
+        tempData.push(data.substring(cursor, nextStart));
+        tempData.push(placeholder);
+        cursor = nextEnd + 1;
+      }
+
+      return tempData.length > 0 ?
+        tempData.join('') + data.substring(cursor, data.length) :
+        data;
+    },
+
+    restore: function(data) {
+      return data.replace(urls.placeholderRegExp, function(placeholder) {
+        return urls.restore(placeholder).replace(/\s/g, '');
+      });
+    }
+  };
+};

data/lib/javascript/clean-css/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "clean-css",
+  "version": "2.2.13",
+  "author": "Jakub Pawlowicz <jakub@goalsmashers.com> (http://twitter.com/GoalSmashers)",
+  "description": "A well-tested CSS minifier",
+  "license": "MIT",
+  "keywords": [
+    "css",
+    "minifier"
+  ],
+  "homepage": "https://github.com/GoalSmashers/clean-css",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GoalSmashers/clean-css.git"
+  },
+  "bugs": {
+    "url": "https://github.com/GoalSmashers/clean-css/issues"
+  },
+  "bin": {
+    "cleancss": "./bin/cleancss"
+  },
+  "main": "index.js",
+  "files": [
+    "bin",
+    "lib",
+    "History.md",
+    "index.js",
+    "LICENSE"
+  ],
+  "scripts": {
+    "browserify": "browserify --standalone CleanCSS index.js | uglifyjs --compress --mangle -o cleancss-browser.js",
+    "bench": "node ./test/bench.js",
+    "check": "jshint ./bin/cleancss .",
+    "prepublish": "jshint .",
+    "test": "vows"
+  },
+  "dependencies": {
+    "commander": "2.3.x"
+  },
+  "devDependencies": {
+    "browserify": "5.x",
+    "jshint": "2.5.x",
+    "nock": "0.28.x",
+    "uglify-js": "2.4.x",
+    "vows": "0.7.x"
+  },
+  "engines": {
+    "node": ">=0.8.0"
+  }
+}