ruby-clean-css 0.0.2

data/lib/javascript/clean-css/lib/colors/hsl-to-hex.js

@@ -0,0 +1,64 @@
+module.exports = function HSLToHex(data) {
+  // HSL to RGB converter. Both methods adapted from:
+  // http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+  var hslToRgb = function(h, s, l) {
+    var r, g, b;
+
+    // normalize hue orientation b/w 0 and 360 degrees
+    h = h % 360;
+    if (h < 0)
+      h += 360;
+    h = ~~h / 360;
+
+    if (s < 0)
+      s = 0;
+    else if (s > 100)
+      s = 100;
+    s = ~~s / 100;
+
+    if (l < 0)
+      l = 0;
+    else if (l > 100)
+      l = 100;
+    l = ~~l / 100;
+
+    if (s === 0) {
+      r = g = b = l; // achromatic
+    } else {
+      var q = l < 0.5 ?
+        l * (1 + s) :
+        l + s - l * s;
+      var p = 2 * l - q;
+      r = hueToRgb(p, q, h + 1/3);
+      g = hueToRgb(p, q, h);
+      b = hueToRgb(p, q, h - 1/3);
+    }
+
+    return [~~(r * 255), ~~(g * 255), ~~(b * 255)];
+  };
+
+  var hueToRgb = function(p, q, t) {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1/6) return p + (q - p) * 6 * t;
+    if (t < 1/2) return q;
+    if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+    return p;
+  };
+
+  return {
+    process: function() {
+      return data.replace(/hsl\((-?\d+),(-?\d+)%?,(-?\d+)%?\)/g, function(match, hue, saturation, lightness) {
+        var asRgb = hslToRgb(hue, saturation, lightness);
+        var redAsHex = asRgb[0].toString(16);
+        var greenAsHex = asRgb[1].toString(16);
+        var blueAsHex = asRgb[2].toString(16);
+
+        return '#' +
+          ((redAsHex.length == 1 ? '0' : '') + redAsHex) +
+          ((greenAsHex.length == 1 ? '0' : '') + greenAsHex) +
+          ((blueAsHex.length == 1 ? '0' : '') + blueAsHex);
+      });
+    }
+  };
+};

data/lib/javascript/clean-css/lib/colors/long-to-short-hex.js

@@ -0,0 +1,12 @@
+module.exports = function LongToShortHex(data) {
+  return {
+    process: function() {
+      return data.replace(/([,: \(])#([0-9a-f]{6})/gi, function(match, prefix, color) {
+        if (color[0] == color[1] && color[2] == color[3] && color[4] == color[5])
+          return prefix + '#' + color[0] + color[2] + color[4];
+        else
+          return prefix + '#' + color;
+      });
+    }
+  };
+};

data/lib/javascript/clean-css/lib/colors/rgb-to-hex.js

@@ -0,0 +1,14 @@
+module.exports = function RGBToHex(data) {
+  return {
+    process: function() {
+      return data.replace(/rgb\((\-?\d+),(\-?\d+),(\-?\d+)\)/g, function(match, red, green, blue) {
+        red = Math.max(0, Math.min(~~red, 255));
+        green = Math.max(0, Math.min(~~green, 255));
+        blue = Math.max(0, Math.min(~~blue, 255));
+
+        // Credit: Asen  http://jsbin.com/UPUmaGOc/2/edit?js,console
+        return '#' + ('00000' + (red << 16 | green << 8 | blue).toString(16)).slice(-6);
+      });
+    }
+  };
+};

data/lib/javascript/clean-css/lib/colors/shortener.js

@@ -0,0 +1,174 @@
+module.exports = function Shortener(data) {
+  var COLORS = {
+    aliceblue: '#f0f8ff',
+    antiquewhite: '#faebd7',
+    aqua: '#0ff',
+    aquamarine: '#7fffd4',
+    azure: '#f0ffff',
+    beige: '#f5f5dc',
+    bisque: '#ffe4c4',
+    black: '#000',
+    blanchedalmond: '#ffebcd',
+    blue: '#00f',
+    blueviolet: '#8a2be2',
+    brown: '#a52a2a',
+    burlywood: '#deb887',
+    cadetblue: '#5f9ea0',
+    chartreuse: '#7fff00',
+    chocolate: '#d2691e',
+    coral: '#ff7f50',
+    cornflowerblue: '#6495ed',
+    cornsilk: '#fff8dc',
+    crimson: '#dc143c',
+    cyan: '#0ff',
+    darkblue: '#00008b',
+    darkcyan: '#008b8b',
+    darkgoldenrod: '#b8860b',
+    darkgray: '#a9a9a9',
+    darkgreen: '#006400',
+    darkkhaki: '#bdb76b',
+    darkmagenta: '#8b008b',
+    darkolivegreen: '#556b2f',
+    darkorange: '#ff8c00',
+    darkorchid: '#9932cc',
+    darkred: '#8b0000',
+    darksalmon: '#e9967a',
+    darkseagreen: '#8fbc8f',
+    darkslateblue: '#483d8b',
+    darkslategray: '#2f4f4f',
+    darkturquoise: '#00ced1',
+    darkviolet: '#9400d3',
+    deeppink: '#ff1493',
+    deepskyblue: '#00bfff',
+    dimgray: '#696969',
+    dodgerblue: '#1e90ff',
+    firebrick: '#b22222',
+    floralwhite: '#fffaf0',
+    forestgreen: '#228b22',
+    fuchsia: '#f0f',
+    gainsboro: '#dcdcdc',
+    ghostwhite: '#f8f8ff',
+    gold: '#ffd700',
+    goldenrod: '#daa520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#adff2f',
+    honeydew: '#f0fff0',
+    hotpink: '#ff69b4',
+    indianred: '#cd5c5c',
+    indigo: '#4b0082',
+    ivory: '#fffff0',
+    khaki: '#f0e68c',
+    lavender: '#e6e6fa',
+    lavenderblush: '#fff0f5',
+    lawngreen: '#7cfc00',
+    lemonchiffon: '#fffacd',
+    lightblue: '#add8e6',
+    lightcoral: '#f08080',
+    lightcyan: '#e0ffff',
+    lightgoldenrodyellow: '#fafad2',
+    lightgray: '#d3d3d3',
+    lightgreen: '#90ee90',
+    lightpink: '#ffb6c1',
+    lightsalmon: '#ffa07a',
+    lightseagreen: '#20b2aa',
+    lightskyblue: '#87cefa',
+    lightslategray: '#778899',
+    lightsteelblue: '#b0c4de',
+    lightyellow: '#ffffe0',
+    lime: '#0f0',
+    limegreen: '#32cd32',
+    linen: '#faf0e6',
+    magenta: '#ff00ff',
+    maroon: '#800000',
+    mediumaquamarine: '#66cdaa',
+    mediumblue: '#0000cd',
+    mediumorchid: '#ba55d3',
+    mediumpurple: '#9370db',
+    mediumseagreen: '#3cb371',
+    mediumslateblue: '#7b68ee',
+    mediumspringgreen: '#00fa9a',
+    mediumturquoise: '#48d1cc',
+    mediumvioletred: '#c71585',
+    midnightblue: '#191970',
+    mintcream: '#f5fffa',
+    mistyrose: '#ffe4e1',
+    moccasin: '#ffe4b5',
+    navajowhite: '#ffdead',
+    navy: '#000080',
+    oldlace: '#fdf5e6',
+    olive: '#808000',
+    olivedrab: '#6b8e23',
+    orange: '#ffa500',
+    orangered: '#ff4500',
+    orchid: '#da70d6',
+    palegoldenrod: '#eee8aa',
+    palegreen: '#98fb98',
+    paleturquoise: '#afeeee',
+    palevioletred: '#db7093',
+    papayawhip: '#ffefd5',
+    peachpuff: '#ffdab9',
+    peru: '#cd853f',
+    pink: '#ffc0cb',
+    plum: '#dda0dd',
+    powderblue: '#b0e0e6',
+    purple: '#800080',
+    red: '#f00',
+    rosybrown: '#bc8f8f',
+    royalblue: '#4169e1',
+    saddlebrown: '#8b4513',
+    salmon: '#fa8072',
+    sandybrown: '#f4a460',
+    seagreen: '#2e8b57',
+    seashell: '#fff5ee',
+    sienna: '#a0522d',
+    silver: '#c0c0c0',
+    skyblue: '#87ceeb',
+    slateblue: '#6a5acd',
+    slategray: '#708090',
+    snow: '#fffafa',
+    springgreen: '#00ff7f',
+    steelblue: '#4682b4',
+    tan: '#d2b48c',
+    teal: '#008080',
+    thistle: '#d8bfd8',
+    tomato: '#ff6347',
+    turquoise: '#40e0d0',
+    violet: '#ee82ee',
+    wheat: '#f5deb3',
+    white: '#fff',
+    whitesmoke: '#f5f5f5',
+    yellow: '#ff0',
+    yellowgreen: '#9acd32'
+  };
+
+  var toHex = {};
+  var toName = {};
+
+  for (var name in COLORS) {
+    var color = COLORS[name];
+    if (name.length < color.length)
+      toName[color] = name;
+    else
+      toHex[name] = color;
+  }
+
+  return {
+    toHex: toHex,
+    toName: toName,
+
+    // replace color name with hex values if shorter (or the other way around)
+    process: function() {
+      [toHex, toName].forEach(function(conversion) {
+        var pattern = '(' + Object.keys(conversion).join('|') + ')';
+        var colorSwitcher = function(match, prefix, colorValue, suffix) {
+          return prefix + conversion[colorValue.toLowerCase()] + suffix;
+        };
+        data = data.replace(new RegExp('([ :,\\(])' + pattern + '([;\\}!\\) ])', 'ig'), colorSwitcher);
+        data = data.replace(new RegExp('(,)' + pattern + '(,)', 'ig'), colorSwitcher);
+      });
+
+      return data;
+    }
+  };
+};

data/lib/javascript/clean-css/lib/images/url-rebase.js

@@ -0,0 +1,32 @@
+var path = require('path');
+
+var UrlRewriter = require('./url-rewriter');
+
+module.exports = function UrlRebase(options, context) {
+  var process = function(data) {
+    var rebaseOpts = {
+      absolute: !!options.root,
+      relative: !options.root && !!options.target,
+      fromBase: options.relativeTo
+    };
+
+    if (!rebaseOpts.absolute && !rebaseOpts.relative)
+      return data;
+
+    if (rebaseOpts.absolute && !!options.target)
+      context.warnings.push('Both \'root\' and output file given so rebasing URLs as absolute paths');
+
+    if (rebaseOpts.absolute)
+      rebaseOpts.toBase = path.resolve(options.root);
+
+    if (rebaseOpts.relative)
+      rebaseOpts.toBase = path.resolve(path.dirname(options.target));
+
+    if (!rebaseOpts.fromBase || !rebaseOpts.toBase)
+      return data;
+
+    return UrlRewriter.process(data, rebaseOpts);
+  };
+
+  return { process: process };
+};

data/lib/javascript/clean-css/lib/images/url-rewriter.js

@@ -0,0 +1,60 @@
+var path = require('path');
+var url = require('url');
+
+module.exports = {
+  process: function(data, options) {
+    var tempData = [];
+    var nextStart = 0;
+    var nextEnd = 0;
+    var cursor = 0;
+
+    for (; nextEnd < data.length;) {
+      nextStart = data.indexOf('url(', nextEnd);
+      if (nextStart == -1)
+        break;
+
+      nextEnd = data.indexOf(')', nextStart + 4);
+      if (nextEnd == -1)
+        break;
+
+      tempData.push(data.substring(cursor, nextStart));
+      var url = data.substring(nextStart + 4, nextEnd);
+      if (!/\/\*|\*\//.test(url))
+        url = url.replace(/['"]/g, '');
+
+      tempData.push('url(' + this._rebased(url, options) + ')');
+      cursor = nextEnd + 1;
+    }
+
+    return tempData.length > 0 ?
+      tempData.join('') + data.substring(cursor, data.length) :
+      data;
+  },
+
+  _rebased: function(resource, options) {
+    var specialUrl = resource[0] == '/' ||
+      resource.substring(resource.length - 4) == '.css' ||
+      resource.indexOf('data:') === 0 ||
+      /^https?:\/\//.exec(resource) !== null ||
+      /__\w+__/.exec(resource) !== null;
+    var rebased;
+
+    if (specialUrl)
+      return resource;
+
+    if (/https?:\/\//.test(options.toBase))
+      return url.resolve(options.toBase, resource);
+
+    if (options.absolute) {
+      rebased = path
+        .resolve(path.join(options.fromBase, resource))
+        .replace(options.toBase, '');
+    } else {
+      rebased = path.relative(options.toBase, path.join(options.fromBase, resource));
+    }
+
+    return process.platform == 'win32' ?
+      rebased.replace(/\\/g, '/') :
+      rebased;
+  }
+};

data/lib/javascript/clean-css/lib/imports/inliner.js

@@ -0,0 +1,319 @@
+var fs = require('fs');
+var path = require('path');
+var http = require('http');
+var https = require('https');
+var url = require('url');
+
+var UrlRewriter = require('../images/url-rewriter');
+
+var merge = function(source1, source2) {
+  var target = {};
+  for (var key1 in source1)
+    target[key1] = source1[key1];
+  for (var key2 in source2)
+    target[key2] = source2[key2];
+
+  return target;
+};
+
+module.exports = function Inliner(context, options) {
+  var defaultOptions = {
+    timeout: 5000,
+    request: {}
+  };
+  var inlinerOptions = merge(defaultOptions, options || {});
+
+  var process = function(data, options) {
+    if (options.shallow) {
+      options.shallow = false;
+      options._shared.done.push(data);
+      return processNext(options);
+    }
+
+    options._shared = options._shared || {
+      done: [],
+      left: []
+    };
+    var shared = options._shared;
+
+    var nextStart = 0;
+    var nextEnd = 0;
+    var cursor = 0;
+    var isComment = commentScanner(data);
+    var afterContent = contentScanner(data);
+
+    options.relativeTo = options.relativeTo || options.root;
+    options._baseRelativeTo = options._baseRelativeTo || options.relativeTo;
+    options.visited = options.visited || [];
+
+    for (; nextEnd < data.length;) {
+      nextStart = data.indexOf('@import', cursor);
+      if (nextStart == -1)
+        break;
+
+      if (isComment(nextStart)) {
+        cursor = nextStart + 1;
+        continue;
+      }
+
+      nextEnd = data.indexOf(';', nextStart);
+      if (nextEnd == -1) {
+        cursor = data.length;
+        data = '';
+        break;
+      }
+
+      shared.done.push(data.substring(0, nextStart));
+      shared.left.unshift([data.substring(nextEnd + 1), options]);
+
+      return afterContent(nextStart) ?
+        processNext(options) :
+        inline(data, nextStart, nextEnd, options);
+    }
+
+    // no @import matched in current data
+    shared.done.push(data);
+    return processNext(options);
+  };
+
+  var processNext = function(options) {
+    if (options._shared.left.length > 0)
+      return process.apply(null, options._shared.left.shift());
+    else
+      return options.whenDone(options._shared.done.join(''));
+  };
+
+  var commentScanner = function(data) {
+    var commentRegex = /(\/\*(?!\*\/)[\s\S]*?\*\/)/;
+    var lastStartIndex = 0;
+    var lastEndIndex = 0;
+    var noComments = false;
+
+    // test whether an index is located within a comment
+    var scanner = function(idx) {
+      var comment;
+      var localStartIndex = 0;
+      var localEndIndex = 0;
+      var globalStartIndex = 0;
+      var globalEndIndex = 0;
+
+      // return if we know there are no more comments
+      if (noComments)
+        return false;
+
+      // idx can be still within last matched comment (many @import statements inside one comment)
+      if (idx > lastStartIndex && idx < lastEndIndex)
+        return true;
+
+      comment = data.match(commentRegex);
+
+      if (!comment) {
+        noComments = true;
+        return false;
+      }
+
+      // get the indexes relative to the current data chunk
+      lastStartIndex = localStartIndex = comment.index;
+      localEndIndex = localStartIndex + comment[0].length;
+
+      // calculate the indexes relative to the full original data
+      globalEndIndex = localEndIndex + lastEndIndex;
+      globalStartIndex = globalEndIndex - comment[0].length;
+
+      // chop off data up to and including current comment block
+      data = data.substring(localEndIndex);
+      lastEndIndex = globalEndIndex;
+
+      // re-run scan if comment ended before the idx
+      if (globalEndIndex < idx)
+        return scanner(idx);
+
+      return globalEndIndex > idx && idx > globalStartIndex;
+    };
+
+    return scanner;
+  };
+
+  var contentScanner = function(data) {
+    var isComment = commentScanner(data);
+    var firstContentIdx = -1;
+    while (true) {
+      firstContentIdx = data.indexOf('{', firstContentIdx + 1);
+      if (firstContentIdx == -1 || !isComment(firstContentIdx))
+        break;
+    }
+
+    return function(idx) {
+      return firstContentIdx > -1 ?
+        idx > firstContentIdx :
+        false;
+    };
+  };
+
+  var inline = function(data, nextStart, nextEnd, options) {
+    options.shallow = data.indexOf('@shallow') > 0;
+
+    var importDeclaration = data
+      .substring(data.indexOf(' ', nextStart) + 1, nextEnd)
+      .replace(/@shallow\)$/, ')')
+      .trim();
+
+    var viaUrl = importDeclaration.indexOf('url(') === 0;
+    var urlStartsAt = viaUrl ? 4 : 0;
+    var isQuoted = /^['"]/.exec(importDeclaration.substring(urlStartsAt, urlStartsAt + 2));
+    var urlEndsAt = isQuoted ?
+      importDeclaration.indexOf(isQuoted[0], urlStartsAt + 1) :
+      importDeclaration.split(' ')[0].length;
+
+    var importedFile = importDeclaration
+      .substring(urlStartsAt, urlEndsAt)
+      .replace(/['"]/g, '')
+      .replace(/\)$/, '')
+      .trim();
+
+    var mediaQuery = importDeclaration
+      .substring(urlEndsAt + 1)
+      .replace(/^\)/, '')
+      .trim();
+
+    var isRemote = options.isRemote ||
+      /^(http|https):\/\//.test(importedFile) ||
+      /^\/\//.test(importedFile);
+
+    if (options.localOnly && isRemote) {
+      context.warnings.push('Ignoring remote @import declaration of "' + importedFile + '" as no callback given.');
+      restoreImport(importedFile, mediaQuery, options);
+
+      return processNext(options);
+    }
+
+    var method = isRemote ? inlineRemoteResource : inlineLocalResource;
+    return method(importedFile, mediaQuery, options);
+  };
+
+  var inlineRemoteResource = function(importedFile, mediaQuery, options) {
+    var importedUrl = /^https?:\/\//.test(importedFile) ?
+      importedFile :
+      url.resolve(options.relativeTo, importedFile);
+
+    if (importedUrl.indexOf('//') === 0)
+      importedUrl = 'http:' + importedUrl;
+
+    if (options.visited.indexOf(importedUrl) > -1)
+      return processNext(options);
+
+
+    if (context.debug)
+      console.error('Inlining remote stylesheet: ' + importedUrl);
+
+    options.visited.push(importedUrl);
+
+    var get = importedUrl.indexOf('http://') === 0 ?
+      http.get :
+      https.get;
+
+    var timedOut = false;
+    var handleError = function(message) {
+      context.errors.push('Broken @import declaration of "' + importedUrl + '" - ' + message);
+      restoreImport(importedUrl, mediaQuery, options);
+
+      processNext(options);
+    };
+    var requestOptions = merge(url.parse(importedUrl), inlinerOptions.request);
+
+    get(requestOptions, function(res) {
+      if (res.statusCode < 200 || res.statusCode > 399) {
+        return handleError('error ' + res.statusCode);
+      } else if (res.statusCode > 299) {
+        var movedUrl = url.resolve(importedUrl, res.headers.location);
+        return inlineRemoteResource(movedUrl, mediaQuery, options);
+      }
+
+      var chunks = [];
+      var parsedUrl = url.parse(importedUrl);
+      res.on('data', function(chunk) {
+        chunks.push(chunk.toString());
+      });
+      res.on('end', function() {
+        var importedData = chunks.join('');
+        importedData = UrlRewriter.process(importedData, { toBase: importedUrl });
+
+        if (mediaQuery.length > 0)
+          importedData = '@media ' + mediaQuery + '{' + importedData + '}';
+
+        process(importedData, {
+          isRemote: true,
+          relativeTo: parsedUrl.protocol + '//' + parsedUrl.host,
+          _shared: options._shared,
+          whenDone: options.whenDone,
+          visited: options.visited,
+          shallow: options.shallow
+        });
+      });
+    })
+    .on('error', function(res) {
+      handleError(res.message);
+    })
+    .on('timeout', function() {
+      // FIX: node 0.8 fires this event twice
+      if (timedOut)
+        return;
+
+      handleError('timeout');
+      timedOut = true;
+    })
+    .setTimeout(inlinerOptions.timeout);
+  };
+
+  var inlineLocalResource = function(importedFile, mediaQuery, options) {
+    var relativeTo = importedFile[0] == '/' ?
+      options.root :
+      options.relativeTo;
+
+    var fullPath = path.resolve(path.join(relativeTo, importedFile));
+
+    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
+      context.errors.push('Broken @import declaration of "' + importedFile + '"');
+      return processNext(options);
+    }
+
+    if (options.visited.indexOf(fullPath) > -1)
+      return processNext(options);
+
+
+    if (context.debug)
+      console.error('Inlining local stylesheet: ' + fullPath);
+
+    options.visited.push(fullPath);
+
+    var importedData = fs.readFileSync(fullPath, 'utf8');
+    var importRelativeTo = path.dirname(fullPath);
+    importedData = UrlRewriter.process(importedData, {
+      relative: true,
+      fromBase: importRelativeTo,
+      toBase: options._baseRelativeTo
+    });
+
+    if (mediaQuery.length > 0)
+      importedData = '@media ' + mediaQuery + '{' + importedData + '}';
+
+    return process(importedData, {
+      root: options.root,
+      relativeTo: importRelativeTo,
+      _baseRelativeTo: options._baseRelativeTo,
+      _shared: options._shared,
+      visited: options.visited,
+      whenDone: options.whenDone,
+      localOnly: options.localOnly,
+      shallow: options.shallow
+    });
+  };
+
+  var restoreImport = function(importedUrl, mediaQuery, options) {
+    var restoredImport = '@import url(' + importedUrl + ')' + (mediaQuery.length > 0 ? ' ' + mediaQuery : '') + ';';
+    options._shared.done.push(restoredImport);
+  };
+
+  // Inlines all imports taking care of repetitions, unknown files, and circular dependencies
+  return { process: process };
+};