ruby-clean-css 0.0.2

data/lib/javascript/clean-css/lib/properties/scanner.js

@@ -0,0 +1,20 @@
+(function() {
+  var OPEN_BRACE = '{';
+  var SEMICOLON = ';';
+  var COLON = ':';
+
+  var PropertyScanner = function PropertyScanner(data) {
+    this.data = data;
+  };
+
+  PropertyScanner.prototype.nextAt = function(cursor) {
+    var lastColon = this.data.lastIndexOf(COLON, cursor);
+    var lastOpenBrace = this.data.lastIndexOf(OPEN_BRACE, cursor);
+    var lastSemicolon = this.data.lastIndexOf(SEMICOLON, cursor);
+    var startAt = Math.max(lastOpenBrace, lastSemicolon);
+
+    return this.data.substring(startAt + 1, lastColon).trim();
+  };
+
+  module.exports = PropertyScanner;
+})();

data/lib/javascript/clean-css/lib/properties/shorthand-compactor.js

@@ -0,0 +1,244 @@
+
+// Compacts the tokens by transforming properties into their shorthand notations when possible
+
+module.exports = (function () {
+  var isHackValue = function (t) { return t.value === '__hack'; };
+
+  var compactShorthands = function(tokens, isImportant, processable, Token) {
+    // Contains the components found so far, grouped by shorthand name
+    var componentsSoFar = { };
+
+    // Initializes a prop in componentsSoFar
+    var initSoFar = function (shprop, last, clearAll) {
+      var found = {};
+      var shorthandPosition;
+
+      if (!clearAll && componentsSoFar[shprop]) {
+        for (var i = 0; i < processable[shprop].components.length; i++) {
+          var prop = processable[shprop].components[i];
+          found[prop] = [];
+
+          if (!(componentsSoFar[shprop].found[prop]))
+            continue;
+
+          for (var ii = 0; ii < componentsSoFar[shprop].found[prop].length; ii++) {
+            var comp = componentsSoFar[shprop].found[prop][ii];
+
+            if (comp.isMarkedForDeletion)
+              continue;
+
+            found[prop].push(comp);
+
+            if (comp.position && (!shorthandPosition || comp.position < shorthandPosition))
+              shorthandPosition = comp.position;
+          }
+        }
+      }
+      componentsSoFar[shprop] = {
+        lastShorthand: last,
+        found: found,
+        shorthandPosition: shorthandPosition
+      };
+    };
+
+    // Adds a component to componentsSoFar
+    var addComponentSoFar = function (token, index) {
+      var shprop = processable[token.prop].componentOf;
+      if (!componentsSoFar[shprop])
+        initSoFar(shprop);
+      if (!componentsSoFar[shprop].found[token.prop])
+        componentsSoFar[shprop].found[token.prop] = [];
+
+      // Add the newfound component to componentsSoFar
+      componentsSoFar[shprop].found[token.prop].push(token);
+
+      if (!componentsSoFar[shprop].shorthandPosition && index) {
+        // If the haven't decided on where the shorthand should go, put it in the place of this component
+        componentsSoFar[shprop].shorthandPosition = index;
+      }
+    };
+
+    // Tries to compact a prop in componentsSoFar
+    var compactSoFar = function (prop) {
+      var i;
+      var componentsCount = processable[prop].components.length;
+
+      // Check basics
+      if (!componentsSoFar[prop] || !componentsSoFar[prop].found)
+        return false;
+
+      // Find components for the shorthand
+      var components = [];
+      var realComponents = [];
+      for (i = 0 ; i < componentsCount; i++) {
+        // Get property name
+        var pp = processable[prop].components[i];
+
+        if (componentsSoFar[prop].found[pp] && componentsSoFar[prop].found[pp].length) {
+          // We really found it
+          var foundRealComp = componentsSoFar[prop].found[pp][0];
+          components.push(foundRealComp);
+          if (foundRealComp.isReal !== false) {
+            realComponents.push(foundRealComp);
+          }
+        } else if (componentsSoFar[prop].lastShorthand) {
+          // It's defined in the previous shorthand
+          var c = componentsSoFar[prop].lastShorthand.components[i].clone(isImportant);
+          components.push(c);
+        } else {
+          // Couldn't find this component at all
+          return false;
+        }
+      }
+
+      if (realComponents.length === 0) {
+        // Couldn't find enough components, sorry
+        return false;
+      }
+
+      if (realComponents.length === componentsCount) {
+        // When all the components are from real values, only allow shorthanding if their understandability allows it
+        // This is the case when every component can override their default values, or when all of them use the same function
+
+        var canOverrideDefault = true;
+        var functionNameMatches = true;
+        var functionName;
+
+        for (var ci = 0; ci < realComponents.length; ci++) {
+          var rc = realComponents[ci];
+
+          if (!processable[rc.prop].canOverride(processable[rc.prop].defaultValue, rc.value)) {
+            canOverrideDefault = false;
+          }
+          var iop = rc.value.indexOf('(');
+          if (iop >= 0) {
+            var otherFunctionName = rc.value.substring(0, iop);
+            if (functionName)
+              functionNameMatches = functionNameMatches && otherFunctionName === functionName;
+            else
+              functionName = otherFunctionName;
+          }
+        }
+
+        if (!canOverrideDefault || !functionNameMatches)
+          return false;
+      }
+
+      // Compact the components into a shorthand
+      var compacted = processable[prop].putTogether(prop, components, isImportant);
+      if (!(compacted instanceof Array)) {
+        compacted = [compacted];
+      }
+
+      var compactedLength = Token.getDetokenizedLength(compacted);
+      var authenticLength = Token.getDetokenizedLength(realComponents);
+
+      if (realComponents.length === componentsCount || compactedLength < authenticLength || components.some(isHackValue)) {
+        compacted[0].isShorthand = true;
+        compacted[0].components = processable[prop].breakUp(compacted[0]);
+
+        // Mark the granular components for deletion
+        for (i = 0; i < realComponents.length; i++) {
+          realComponents[i].isMarkedForDeletion = true;
+        }
+
+        // Mark the position of the new shorthand
+        tokens[componentsSoFar[prop].shorthandPosition].replaceWith = compacted;
+
+        // Reinitialize the thing for further compacting
+        initSoFar(prop, compacted[0]);
+        for (i = 1; i < compacted.length; i++) {
+          addComponentSoFar(compacted[i]);
+        }
+
+        // Yes, we can keep the new shorthand!
+        return true;
+      }
+
+      return false;
+    };
+
+    // Tries to compact all properties currently in componentsSoFar
+    var compactAllSoFar = function () {
+      for (var i in componentsSoFar) {
+        if (componentsSoFar.hasOwnProperty(i)) {
+          while (compactSoFar(i)) { }
+        }
+      }
+    };
+
+    var i, token;
+
+    // Go through each token and collect components for each shorthand as we go on
+    for (i = 0; i < tokens.length; i++) {
+      token = tokens[i];
+      if (token.isMarkedForDeletion) {
+        continue;
+      }
+      if (!processable[token.prop]) {
+        // We don't know what it is, move on
+        continue;
+      }
+      if (processable[token.prop].isShorthand) {
+        // Found an instance of a full shorthand
+        // NOTE: we should NOT mix together tokens that come before and after the shorthands
+
+        if (token.isImportant === isImportant || (token.isImportant && !isImportant)) {
+          // Try to compact what we've found so far
+          while (compactSoFar(token.prop)) { }
+          // Reset
+          initSoFar(token.prop, token, true);
+        }
+
+        // TODO: when the old optimizer is removed, take care of this corner case:
+        //   div{background-color:#111;background-image:url(aaa);background:linear-gradient(aaa);background-repeat:no-repeat;background-position:1px 2px;background-attachment:scroll}
+        //   -> should not be shorthanded / minified at all because the result wouldn't be equivalent to the original in any browser
+      } else if (processable[token.prop].componentOf) {
+        // Found a component of a shorthand
+        if (token.isImportant === isImportant) {
+          // Same importantness
+          token.position = i;
+          addComponentSoFar(token, i);
+        } else if (!isImportant && token.isImportant) {
+          // Use importants for optimalization opportunities
+          // https://github.com/GoalSmashers/clean-css/issues/184
+          var importantTrickComp = new Token(token.prop, token.value, isImportant);
+          importantTrickComp.isIrrelevant = true;
+          importantTrickComp.isReal = false;
+          addComponentSoFar(importantTrickComp);
+        }
+      } else {
+        // This is not a shorthand and not a component, don't care about it
+        continue;
+      }
+    }
+
+    // Perform all possible compactions
+    compactAllSoFar();
+
+    // Process the results - throw away stuff marked for deletion, insert compacted things, etc.
+    var result = [];
+    for (i = 0; i < tokens.length; i++) {
+      token = tokens[i];
+
+      if (token.replaceWith) {
+        for (var ii = 0; ii < token.replaceWith.length; ii++) {
+          result.push(token.replaceWith[ii]);
+        }
+      }
+      if (!token.isMarkedForDeletion) {
+        result.push(token);
+      }
+
+      token.isMarkedForDeletion = false;
+      token.replaceWith = null;
+    }
+
+    return result;
+  };
+
+  return {
+    compactShorthands: compactShorthands
+  };
+
+})();

data/lib/javascript/clean-css/lib/properties/token.js

@@ -0,0 +1,184 @@
+
+// Helper for tokenizing the contents of a CSS selector block
+
+module.exports = (function() {
+  var createTokenPrototype = function (processable) {
+    var important = '!important';
+
+    // Constructor for tokens
+    function Token (prop, p2, p3) {
+      this.prop = prop;
+      if (typeof(p2) === 'string') {
+        this.value = p2;
+        this.isImportant = p3;
+      }
+      else {
+        this.value = processable[prop].defaultValue;
+        this.isImportant = p2;
+      }
+    }
+
+    Token.prototype.prop = null;
+    Token.prototype.value = null;
+    Token.prototype.granularValues = null;
+    Token.prototype.components = null;
+    Token.prototype.position = null;
+    Token.prototype.isImportant = false;
+    Token.prototype.isDirty = false;
+    Token.prototype.isShorthand = false;
+    Token.prototype.isIrrelevant = false;
+    Token.prototype.isReal = true;
+    Token.prototype.isMarkedForDeletion = false;
+
+    // Tells if this token is a component of the other one
+    Token.prototype.isComponentOf = function (other) {
+      if (!processable[this.prop] || !processable[other.prop])
+        return false;
+      if (!(processable[other.prop].components instanceof Array) || !processable[other.prop].components.length)
+        return false;
+
+      return processable[other.prop].components.indexOf(this.prop) >= 0;
+    };
+
+    // Clones a token
+    Token.prototype.clone = function (isImportant) {
+      var token = new Token(this.prop, this.value, (typeof(isImportant) !== 'undefined' ? isImportant : this.isImportant));
+      return token;
+    };
+
+    // Creates an irrelevant token with the same prop
+    Token.prototype.cloneIrrelevant = function (isImportant) {
+      var token = Token.makeDefault(this.prop, (typeof(isImportant) !== 'undefined' ? isImportant : this.isImportant));
+      token.isIrrelevant = true;
+      return token;
+    };
+
+    // Creates an array of property tokens with their default values
+    Token.makeDefaults = function (props, important) {
+      return props.map(function(prop) {
+        return new Token(prop, important);
+      });
+    };
+
+    // Parses one CSS property declaration into a token
+    Token.tokenizeOne = function (fullProp) {
+      // Find first colon
+      var colonPos = fullProp.indexOf(':');
+
+      if (colonPos < 0) {
+        // This property doesn't have a colon, it's invalid. Let's keep it intact anyway.
+        return new Token('', fullProp);
+      }
+
+      // Parse parts of the property
+      var prop = fullProp.substr(0, colonPos).trim();
+      var value = fullProp.substr(colonPos + 1).trim();
+      var isImportant = false;
+      var importantPos = value.indexOf(important);
+
+      // Check if the property is important
+      if (importantPos >= 1 && importantPos === value.length - important.length) {
+        value = value.substr(0, importantPos).trim();
+        isImportant = true;
+      }
+
+      // Return result
+      var result = new Token(prop, value, isImportant);
+
+      // If this is a shorthand, break up its values
+      // NOTE: we need to do this for all shorthands because otherwise we couldn't remove default values from them
+      if (processable[prop] && processable[prop].isShorthand) {
+        result.isShorthand = true;
+        result.components = processable[prop].breakUp(result);
+        result.isDirty = true;
+      }
+
+      return result;
+    };
+
+    // Breaks up a string of CSS property declarations into tokens so that they can be handled more easily
+    Token.tokenize = function (input) {
+      // Split the input by semicolons and parse the parts
+      var tokens = input.split(';').map(Token.tokenizeOne);
+      return tokens;
+    };
+
+    // Transforms tokens back into CSS properties
+    Token.detokenize = function (tokens) {
+      // If by mistake the input is not an array, make it an array
+      if (!(tokens instanceof Array)) {
+        tokens = [tokens];
+      }
+
+      var result = '';
+
+      // This step takes care of putting together the components of shorthands
+      // NOTE: this is necessary to do for every shorthand, otherwise we couldn't remove their default values
+      for (var i = 0; i < tokens.length; i++) {
+        var t = tokens[i];
+        if (t.isShorthand && t.isDirty) {
+          var news = processable[t.prop].putTogether(t.prop, t.components, t.isImportant);
+          Array.prototype.splice.apply(tokens, [i, 1].concat(news));
+          t.isDirty = false;
+          i--;
+          continue;
+        }
+
+        if (t.prop)
+          result += t.prop + ':';
+
+        if (t.value)
+          result += t.value;
+
+        if (t.isImportant)
+          result += important;
+
+        result += ';';
+      }
+
+      return result.substr(0, result.length - 1);
+    };
+
+    // Gets the final (detokenized) length of the given tokens
+    Token.getDetokenizedLength = function (tokens) {
+      // If by mistake the input is not an array, make it an array
+      if (!(tokens instanceof Array)) {
+        tokens = [tokens];
+      }
+
+      var result = 0;
+
+      // This step takes care of putting together the components of shorthands
+      // NOTE: this is necessary to do for every shorthand, otherwise we couldn't remove their default values
+      for (var i = 0; i < tokens.length; i++) {
+        var t = tokens[i];
+        if (t.isShorthand && t.isDirty) {
+          var news = processable[t.prop].putTogether(t.prop, t.components, t.isImportant);
+          Array.prototype.splice.apply(tokens, [i, 1].concat(news));
+          t.isDirty = false;
+          i--;
+          continue;
+        }
+
+        if (t.prop) {
+          result += t.prop.length + 1;
+        }
+        if (t.value) {
+          result += t.value.length;
+        }
+        if (t.isImportant) {
+          result += important.length;
+        }
+      }
+
+      return result;
+    };
+
+    return Token;
+  };
+
+  return {
+    createTokenPrototype: createTokenPrototype
+  };
+
+})();

data/lib/javascript/clean-css/lib/properties/validator.js

@@ -0,0 +1,140 @@
+
+// Validates various CSS property values
+
+var Splitter = require('../text/splitter');
+
+module.exports = (function () {
+  // Regexes used for stuff
+  var widthKeywords = ['thin', 'thick', 'medium', 'inherit', 'initial'];
+  var cssUnitRegexStr = '(\\-?\\.?\\d+\\.?\\d*(px|%|em|rem|in|cm|mm|ex|pt|pc|vw|vh|vmin|vmax|)|auto|inherit)';
+  var cssFunctionNoVendorRegexStr = '[A-Z]+(\\-|[A-Z]|[0-9])+\\(([A-Z]|[0-9]|\\ |\\,|\\#|\\+|\\-|\\%|\\.|\\(|\\))*\\)';
+  var cssFunctionVendorRegexStr = '\\-(\\-|[A-Z]|[0-9])+\\(([A-Z]|[0-9]|\\ |\\,|\\#|\\+|\\-|\\%|\\.|\\(|\\))*\\)';
+  var cssVariableRegexStr = 'var\\(\\-\\-[^\\)]+\\)';
+  var cssFunctionAnyRegexStr = '(' + cssVariableRegexStr + '|' + cssFunctionNoVendorRegexStr + '|' + cssFunctionVendorRegexStr + ')';
+  var cssUnitAnyRegexStr = '(none|' + widthKeywords.join('|') + '|' + cssUnitRegexStr + '|' + cssVariableRegexStr + '|' + cssFunctionNoVendorRegexStr + '|' + cssFunctionVendorRegexStr + ')';
+
+  var cssFunctionNoVendorRegex = new RegExp('^' + cssFunctionNoVendorRegexStr + '$', 'i');
+  var cssFunctionVendorRegex = new RegExp('^' + cssFunctionVendorRegexStr + '$', 'i');
+  var cssVariableRegex = new RegExp('^' + cssVariableRegexStr + '$', 'i');
+  var cssFunctionAnyRegex = new RegExp('^' + cssFunctionAnyRegexStr + '$', 'i');
+  var cssUnitRegex = new RegExp('^' + cssUnitRegexStr + '$', 'i');
+  var cssUnitAnyRegex = new RegExp('^' + cssUnitAnyRegexStr + '$', 'i');
+
+  var backgroundRepeatKeywords = ['repeat', 'no-repeat', 'repeat-x', 'repeat-y', 'inherit'];
+  var backgroundAttachmentKeywords = ['inherit', 'scroll', 'fixed', 'local'];
+  var backgroundPositionKeywords = ['center', 'top', 'bottom', 'left', 'right'];
+  var backgroundSizeKeywords = ['contain', 'cover'];
+  var listStyleTypeKeywords = ['armenian', 'circle', 'cjk-ideographic', 'decimal', 'decimal-leading-zero', 'disc', 'georgian', 'hebrew', 'hiragana', 'hiragana-iroha', 'inherit', 'katakana', 'katakana-iroha', 'lower-alpha', 'lower-greek', 'lower-latin', 'lower-roman', 'none', 'square', 'upper-alpha', 'upper-latin', 'upper-roman'];
+  var listStylePositionKeywords = ['inside', 'outside', 'inherit'];
+  var outlineStyleKeywords = ['auto', 'inherit', 'hidden', 'none', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset'];
+
+  var validator = {
+    isValidHexColor: function (s) {
+      return (s.length === 4 || s.length === 7) && s[0] === '#';
+    },
+    isValidRgbaColor: function (s) {
+      s = s.split(' ').join('');
+      return s.length > 0 && s.indexOf('rgba(') === 0 && s.indexOf(')') === s.length - 1;
+    },
+    isValidHslaColor: function (s) {
+      s = s.split(' ').join('');
+      return s.length > 0 && s.indexOf('hsla(') === 0 && s.indexOf(')') === s.length - 1;
+    },
+    isValidNamedColor: function (s) {
+      // We don't really check if it's a valid color value, but allow any letters in it
+      return s !== 'auto' && (s === 'transparent' || s === 'inherit' || /^[a-zA-Z]+$/.test(s));
+    },
+    isValidVariable: function(s) {
+      return cssVariableRegex.test(s);
+    },
+    isValidColor: function (s) {
+      return validator.isValidNamedColor(s) || validator.isValidHexColor(s) || validator.isValidRgbaColor(s) || validator.isValidHslaColor(s) || validator.isValidVariable(s);
+    },
+    isValidUrl: function (s) {
+      // NOTE: at this point all URLs are replaced with placeholders by clean-css, so we check for those placeholders
+      return s.indexOf('__ESCAPED_URL_CLEAN_CSS') === 0;
+    },
+    isValidUnit: function (s) {
+      return cssUnitAnyRegex.test(s);
+    },
+    isValidUnitWithoutFunction: function (s) {
+      return cssUnitRegex.test(s);
+    },
+    isValidFunctionWithoutVendorPrefix: function (s) {
+      return cssFunctionNoVendorRegex.test(s);
+    },
+    isValidFunctionWithVendorPrefix: function (s) {
+      return cssFunctionVendorRegex.test(s);
+    },
+    isValidFunction: function (s) {
+      return cssFunctionAnyRegex.test(s);
+    },
+    isValidBackgroundRepeat: function (s) {
+      return backgroundRepeatKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidBackgroundAttachment: function (s) {
+      return backgroundAttachmentKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidBackgroundPositionPart: function (s) {
+      if (backgroundPositionKeywords.indexOf(s) >= 0)
+        return true;
+
+      return cssUnitRegex.test(s) || validator.isValidVariable(s);
+    },
+    isValidBackgroundPosition: function (s) {
+      if (s === 'inherit')
+        return true;
+
+      var parts = s.split(' ');
+      for (var i = 0, l = parts.length; i < l; i++) {
+        if (parts[i] === '')
+          continue;
+        if (validator.isValidBackgroundPositionPart(parts[i]) || validator.isValidVariable(parts[i]))
+          continue;
+
+        return false;
+      }
+
+      return true;
+    },
+    isValidBackgroundSizePart: function(s) {
+      return backgroundSizeKeywords.indexOf(s) >= 0 || cssUnitRegex.test(s) || validator.isValidVariable(s);
+    },
+    isValidBackgroundPositionAndSize: function(s) {
+      if (s.indexOf('/') < 0)
+        return false;
+
+      var twoParts = new Splitter('/').split(s);
+      return validator.isValidBackgroundSizePart(twoParts.pop()) && validator.isValidBackgroundPositionPart(twoParts.pop());
+    },
+    isValidListStyleType: function (s) {
+      return listStyleTypeKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidListStylePosition: function (s) {
+      return listStylePositionKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidOutlineColor: function (s) {
+      return s === 'invert' || validator.isValidColor(s) || validator.isValidVendorPrefixedValue(s);
+    },
+    isValidOutlineStyle: function (s) {
+      return outlineStyleKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidOutlineWidth: function (s) {
+      return validator.isValidUnit(s) || widthKeywords.indexOf(s) >= 0 || validator.isValidVariable(s);
+    },
+    isValidVendorPrefixedValue: function (s) {
+      return /^-([A-Za-z0-9]|-)*$/gi.test(s);
+    },
+    areSameFunction: function (a, b) {
+      if (!validator.isValidFunction(a) || !validator.isValidFunction(b))
+        return false;
+
+      var f1name = a.substring(0, a.indexOf('('));
+      var f2name = b.substring(0, b.indexOf('('));
+
+      return f1name === f2name;
+    }
+  };
+
+  return validator;
+})();