Cleans up serializer code.

Why:

* Makes serialization context always the first argument;
* renamed function names for better clarity.

diff --git a/lib/writer/helpers.js b/lib/writer/helpers.js
index bb30795..0b8999e 100644 (file)
--- a/lib/writer/helpers.js
+++ b/lib/writer/helpers.js
@@ -35,7 +35,7 @@ function inFilter(token) {
   return token[1][1] == 'filter' || token[1][1] == '-ms-filter';
 }
 
-function inSpecialContext(token, valueIndex, context) {
+function disallowsSpace(context, token, valueIndex) {
   return !context.spaceAfterClosingBrace && supportsAfterClosingBrace(token) && afterClosingBrace(token, valueIndex) ||
     beforeSlash(token, valueIndex) ||
     afterSlash(token, valueIndex) ||
@@ -43,23 +43,23 @@ function inSpecialContext(token, valueIndex, context) {
     afterComma(token, valueIndex);
 }
 
-function rules(tokens, context) {
+function rules(context, tokens) {
   var store = context.store;
 
   for (var i = 0, l = tokens.length; i < l; i++) {
-    store(tokens[i], context);
+    store(context, tokens[i]);
 
     if (i < l - 1) {
-      store(comma(context), context);
+      store(context, comma(context));
     }
   }
 }
 
-function body(tokens, context) {
+function body(context, tokens) {
   var lastPropertyAt = lastPropertyIndex(tokens);
 
   for (var i = 0, l = tokens.length; i < l; i++) {
-    property(tokens, i, lastPropertyAt, context);
+    property(context, tokens, i, lastPropertyAt);
   }
 }
 
@@ -75,7 +75,7 @@ function lastPropertyIndex(tokens) {
   return index;
 }
 
-function property(tokens, position, lastPropertyAt, context) {
+function property(context, tokens, position, lastPropertyAt) {
   var store = context.store;
   var token = tokens[position];
   var isPropertyBlock = token[2][0] == Token.PROPERTY_BLOCK;
@@ -84,34 +84,34 @@ function property(tokens, position, lastPropertyAt, context) {
 
   switch (token[0]) {
     case Token.AT_RULE:
-      store(token, context);
-      store(position < lastPropertyAt ? semicolon(context, Breaks.AfterProperty, false) : emptyCharacter, context);
+      store(context, token);
+      store(context, position < lastPropertyAt ? semicolon(context, Breaks.AfterProperty, false) : emptyCharacter);
       break;
     case Token.COMMENT:
-      store(token, context);
+      store(context, token);
       break;
     case Token.PROPERTY:
-      store(token[1], context);
-      store(colon(context), context);
-      value(token, context);
-      store(needsSemicolon ? semicolon(context, Breaks.AfterProperty, isLast) : emptyCharacter, context);
+      store(context, token[1]);
+      store(context, colon(context));
+      value(context, token);
+      store(context, needsSemicolon ? semicolon(context, Breaks.AfterProperty, isLast) : emptyCharacter);
   }
 }
 
-function value(token, context) {
+function value(context, token) {
   var store = context.store;
   var j, m;
 
   if (token[2][0] == Token.PROPERTY_BLOCK) {
-    store(openBrace(context, Breaks.AfterBlockBegins, false), context);
-    body(token[2][1], context);
-    store(closeBrace(context, Breaks.AfterBlockEnds, false, true), context);
+    store(context, openBrace(context, Breaks.AfterBlockBegins, false));
+    body(context, token[2][1]);
+    store(context, closeBrace(context, Breaks.AfterBlockEnds, false, true));
   } else {
     for (j = 2, m = token.length; j < m; j++) {
-      store(token[j], context);
+      store(context, token[j]);
 
-      if (j < m - 1 && (inFilter(token) || !inSpecialContext(token, j, context))) {
-        store(Marker.SPACE, context);
+      if (j < m - 1 && (inFilter(token) || !disallowsSpace(context, token, j))) {
+        store(context, Marker.SPACE);
       }
     }
   }
@@ -169,7 +169,7 @@ function comma(context) {
     Marker.COMMA;
 }
 
-function all(tokens, context) {
+function all(context, tokens) {
   var store = context.store;
   var token;
   var isLast;
@@ -181,30 +181,30 @@ function all(tokens, context) {
 
     switch (token[0]) {
       case Token.AT_RULE:
-        store(token, context);
-        store(semicolon(context, Breaks.AfterAtRule, isLast), context);
+        store(context, token);
+        store(context, semicolon(context, Breaks.AfterAtRule, isLast));
         break;
       case Token.AT_RULE_BLOCK:
-        rules(token[1], context);
-        store(openBrace(context, Breaks.AfterRuleBegins, true), context);
-        body(token[2], context);
-        store(closeBrace(context, Breaks.AfterRuleEnds, false, isLast), context);
+        rules(context, token[1]);
+        store(context, openBrace(context, Breaks.AfterRuleBegins, true));
+        body(context, token[2]);
+        store(context, closeBrace(context, Breaks.AfterRuleEnds, false, isLast));
         break;
       case Token.NESTED_BLOCK:
-        rules(token[1], context);
-        store(openBrace(context, Breaks.AfterBlockBegins, true), context);
-        all(token[2], context);
-        store(closeBrace(context, Breaks.AfterBlockEnds, true, isLast), context);
+        rules(context, token[1]);
+        store(context, openBrace(context, Breaks.AfterBlockBegins, true));
+        all(context, token[2]);
+        store(context, closeBrace(context, Breaks.AfterBlockEnds, true, isLast));
         break;
       case Token.COMMENT:
-        store(token, context);
-        store(allowsBreak(context, Breaks.AfterComment) ? lineBreak : emptyCharacter, context);
+        store(context, token);
+        store(context, allowsBreak(context, Breaks.AfterComment) ? lineBreak : emptyCharacter);
         break;
       case Token.RULE:
-        rules(token[1], context);
-        store(openBrace(context, Breaks.AfterRuleBegins, true), context);
-        body(token[2], context);
-        store(closeBrace(context, Breaks.AfterRuleEnds, false, isLast), context);
+        rules(context, token[1]);
+        store(context, openBrace(context, Breaks.AfterRuleBegins, true));
+        body(context, token[2]);
+        store(context, closeBrace(context, Breaks.AfterRuleEnds, false, isLast));
         break;
     }
   }

diff --git a/lib/writer/one-time.js b/lib/writer/one-time.js
index 2f2e767..33fccea 100644 (file)
--- a/lib/writer/one-time.js
+++ b/lib/writer/one-time.js
@@ -1,44 +1,46 @@
 var helpers = require('./helpers');
 
-function store(token, context) {
-  context.output.push(typeof token == 'string' ? token : token[1]);
+function store(serializeContext, token) {
+  serializeContext.output.push(typeof token == 'string' ? token : token[1]);
 }
 
 function context() {
-  return {
+  var newContext = {
     output: [],
     store: store
   };
+
+  return newContext;
 }
 
 function all(tokens) {
-  var fakeContext = context();
-  helpers.all(tokens, fakeContext);
-  return fakeContext.output.join('');
+  var oneTimeContext = context();
+  helpers.all(oneTimeContext, tokens);
+  return oneTimeContext.output.join('');
 }
 
 function body(tokens) {
-  var fakeContext = context();
-  helpers.body(tokens, fakeContext);
-  return fakeContext.output.join('');
+  var oneTimeContext = context();
+  helpers.body(oneTimeContext, tokens);
+  return oneTimeContext.output.join('');
 }
 
 function property(tokens, position) {
-  var fakeContext = context();
-  helpers.property(tokens, position, true, fakeContext);
-  return fakeContext.output.join('');
+  var oneTimeContext = context();
+  helpers.property(oneTimeContext, tokens, position, true);
+  return oneTimeContext.output.join('');
 }
 
 function rules(tokens) {
-  var fakeContext = context();
-  helpers.rules(tokens, fakeContext);
-  return fakeContext.output.join('');
+  var oneTimeContext = context();
+  helpers.rules(oneTimeContext, tokens);
+  return oneTimeContext.output.join('');
 }
 
 function value(tokens) {
-  var fakeContext = context();
-  helpers.value(tokens, fakeContext);
-  return fakeContext.output.join('');
+  var oneTimeContext = context();
+  helpers.value(oneTimeContext, tokens);
+  return oneTimeContext.output.join('');
 }
 
 module.exports = {

diff --git a/lib/writer/simple.js b/lib/writer/simple.js
index 5bb16d1..21e7f88 100644 (file)
--- a/lib/writer/simple.js
+++ b/lib/writer/simple.js
@@ -2,24 +2,25 @@ var all = require('./helpers').all;
 
 var lineBreak = require('os').EOL;
 
-function store(token, serializeContext) {
+function store(serializeContext, token) {
   var value = typeof token == 'string' ?
     token :
     token[1];
+  var wrap = serializeContext.wrap;
 
-  serializeContext.wrap(value);
-  serializeContext.track(value);
+  wrap(serializeContext, value);
+  track(serializeContext, value);
   serializeContext.output.push(value);
 }
 
-function wrap(value, serializeContext) {
+function wrap(serializeContext, value) {
   if (serializeContext.column + value.length > serializeContext.format.wrapAt) {
-    track(lineBreak, serializeContext);
+    track(serializeContext, lineBreak);
     serializeContext.output.push(lineBreak);
   }
 }
 
-function track(value, serializeContext) {
+function track(serializeContext, value) {
   var parts = value.split('\n');
 
   serializeContext.line += parts.length - 1;
@@ -36,15 +37,12 @@ function serializeStyles(tokens, context) {
     output: [],
     spaceAfterClosingBrace: context.options.compatibility.properties.spaceAfterClosingBrace,
     store: store,
-    track: context.options.format.wrapAt ?
-      function (value) { track(value, serializeContext); } :
-      function () { /* noop */  },
     wrap: context.options.format.wrapAt ?
-      function (value) { wrap(value, serializeContext); } :
+      wrap :
       function () { /* noop */  }
   };
 
-  all(tokens, serializeContext, false);
+  all(serializeContext, tokens);
 
   return {
     styles: serializeContext.output.join('')

diff --git a/lib/writer/source-maps.js b/lib/writer/source-maps.js
index f58db4f..4729eb0 100644 (file)
--- a/lib/writer/source-maps.js
+++ b/lib/writer/source-maps.js
@@ -10,41 +10,42 @@ var NIX_SEPARATOR_PATTERN = /\//g;
 var UNKNOWN_SOURCE = '$stdin';
 var WINDOWS_SEPARATOR = '\\';
 
-function store(element, serializeContext) {
+function store(serializeContext, element) {
   var fromString = typeof element == 'string';
   var value = fromString ? element : element[1];
   var mappings = fromString ? null : element[2];
+  var wrap = serializeContext.wrap;
 
-  serializeContext.wrap(value);
-  track(value, mappings, serializeContext);
+  wrap(serializeContext, value);
+  track(serializeContext, value, mappings);
   serializeContext.output.push(value);
 }
 
-function wrap(value, serializeContext) {
+function wrap(serializeContext, value) {
   if (serializeContext.column + value.length > serializeContext.format.wrapAt) {
-    track(lineBreak, false, serializeContext);
+    track(serializeContext, lineBreak, false);
     serializeContext.output.push(lineBreak);
   }
 }
 
-function track(value, mappings, serializeContext) {
+function track(serializeContext, value, mappings) {
   var parts = value.split('\n');
 
   if (mappings) {
-    trackAllMappings(mappings, serializeContext);
+    trackAllMappings(serializeContext, mappings);
   }
 
   serializeContext.line += parts.length - 1;
   serializeContext.column = parts.length > 1 ? 0 : (serializeContext.column + parts.pop().length);
 }
 
-function trackAllMappings(mappings, serializeContext) {
+function trackAllMappings(serializeContext, mappings) {
   for (var i = 0, l = mappings.length; i < l; i++) {
-    trackMapping(mappings[i], serializeContext);
+    trackMapping(serializeContext, mappings[i]);
   }
 }
 
-function trackMapping(mapping, serializeContext) {
+function trackMapping(serializeContext, mapping) {
   var line = mapping[0];
   var column = mapping[1];
   var originalSource = mapping[2];
@@ -86,11 +87,11 @@ function serializeStylesAndSourceMap(tokens, context) {
     spaceAfterClosingBrace: context.options.compatibility.properties.spaceAfterClosingBrace,
     store: store,
     wrap: context.options.format.wrapAt ?
-      function (value) { wrap(value, serializeContext); } :
+      wrap :
       function () { /* noop */  }
   };
 
-  all(tokens, serializeContext, false);
+  all(serializeContext, tokens);
 
   return {
     sourceMap: serializeContext.outputMap,