Merge pull request #11 from css-modules/warn-implicit

Warn implicit

Author: sokra

index.js

@@ -30,12 +30,15 @@ function localizeNode(node, context) {
   switch(node.type) {
     case "selectors":
       var resultingGlobal;
-      context.locals = true;
+      context.hasPureGlobals = false;
+      context.hasPureImplicitGlobals = false;
       newNodes = node.nodes.map(function(n) {
         var nContext = {
           global: context.global,
           lastWasSpacing: true,
-          locals: false
+          hasLocals: false,
+          hasImplicitGlobals: false,
+          explicit: false
         };
         n = localizeNode(n, nContext);
         if(typeof resultingGlobal === "undefined") {
@@ -44,8 +47,11 @@ function localizeNode(node, context) {
           throw new Error("Inconsistent rule global/local result in rule '" +
             Tokenizer.stringify(node) + "' (multiple selectors must result in the same mode for the rule)");
         }
-        if(!nContext.locals) {
-          context.locals = false;
+        if(!nContext.hasLocals) {
+          context.hasPureGlobals = true;
+          if(nContext.hasImplicitGlobals) {
+            context.hasPureImplicitGlobals = true;
+          }
         }
         return n;
       });
@@ -80,6 +86,7 @@ function localizeNode(node, context) {
         context.ignoreNextSpacing = context.lastWasSpacing ? node.name : false;
         context.enforceNoSpacing = context.lastWasSpacing ? false : node.name;
         context.global = (node.name === "global");
+        context.explicit = true;
         return null;
       }
       break;
@@ -93,32 +100,43 @@ function localizeNode(node, context) {
         subContext = {
           global: (node.name === "global"),
           inside: node.name,
-          locals: false
+          hasLocals: false,
+          hasImplicitGlobals: false,
+          explicit: true
         };
         node = node.nodes.map(function(n) {
           return localizeNode(n, subContext);
         });
         // don't leak spacing
         node[0].before = undefined;
         node[node.length - 1].after = undefined;
-        if(subContext.locals) {
-          context.locals = true;
-        }
       } else {
         subContext = {
           global: context.global,
           inside: context.inside,
           lastWasSpacing: true,
-          locals: false
+          hasLocals: false,
+          hasImplicitGlobals: false,
+          explicit: context.explicit
         };
         newNodes = node.nodes.map(function(n) {
           return localizeNode(n, subContext);
         });
         node = Object.create(node);
         node.nodes = normalizeNodeArray(newNodes);
-        if(subContext.locals) {
-          context.locals = true;
-        }
+      }
+      if(subContext.hasLocals) {
+        context.hasLocals = true;
+      }
+      if(subContext.hasImplicitGlobals) {
+        context.hasImplicitGlobals = true;
+      }
+      break;
+
+    case "attribute":
+    case "element":
+      if(!context.global && !context.explicit) {
+        context.hasImplicitGlobals = true;
       }
       break;
 
@@ -130,7 +148,7 @@ function localizeNode(node, context) {
           name: "local",
           nodes: [node]
         };
-        context.locals = true;
+        context.hasLocals = true;
       }
       break;
   }
@@ -177,13 +195,18 @@ module.exports = postcss.plugin('postcss-modules-local-by-default', function (op
       var selector = Tokenizer.parse(rule.selector);
       var context = {
         global: globalMode,
-        locals: false
+        hasPureGlobals: false,
+        hasPureImplicitGlobals: false
       };
       var newSelector = localizeNode(selector, context);
-      if(pureMode && !context.locals) {
+      if(pureMode && context.hasPureGlobals) {
         throw new Error("Selector '" + Tokenizer.stringify(selector) + "' is not pure " +
           "(pure selectors must contain at least one local class or id)");
       }
+      if(!globalMode && context.hasPureImplicitGlobals) {
+        throw new Error("Selector '" + Tokenizer.stringify(selector) + "' must be explicit flagged :global " +
+          "(elsewise it would leak globally)");
+      }
       if(!context.global) {
         rule.nodes.forEach(localizeDecl);
       }

test.js

@@ -235,6 +235,22 @@ var tests = [
     input: ':import("~/lol.css") { foo: __foo; }',
     expected: ':import("~/lol.css") { foo: __foo; }'
   },
+  {
+    should: 'compile in pure mode',
+    input: ':global(.foo).bar, [type="radio"] ~ .label, :not(.foo), #bar {}',
+    options: { mode: "pure" },
+    expected: '.foo:local(.bar), [type="radio"] ~ :local(.label), :not(:local(.foo)), :local(#bar) {}'
+  },
+  {
+    should: 'compile explict global element',
+    input: ':global(input) {}',
+    expected: 'input {}'
+  },
+  {
+    should: 'compile explict global attribute',
+    input: ':global([type="radio"]), :not(:global [type="radio"]) {}',
+    expected: '[type="radio"], :not([type="radio"]) {}'
+  },
 
   {
     should: 'throw on invalid mode',
@@ -283,12 +299,6 @@ var tests = [
     options: { mode: "pure" },
     error: /':global\(\.foo\)' is not pure/
   },
-  {
-    should: 'compile in pure mode',
-    input: ':global(.foo).bar, [type="radio"] ~ .label, :not(.foo), #bar {}',
-    options: { mode: "pure" },
-    expected: '.foo:local(.bar), [type="radio"] ~ :local(.label), :not(:local(.foo)), :local(#bar) {}'
-  },
   {
     should: 'throw on not pure selector (with multiple 1)',
     input: '.foo, :global(.bar) {}',
@@ -318,6 +328,31 @@ var tests = [
     input: '@keyframes :global(foo) {}',
     options: { mode: "pure" },
     error: /@keyframes :global\(\.\.\.\) is not allowed in pure mode/
+  },
+  {
+    should: 'throw on implicit global element',
+    input: 'input {}',
+    error: /'input' must be explicit flagged :global/
+  },
+  {
+    should: 'throw on implicit global element (with multiple 1)',
+    input: 'input, .foo {}',
+    error: /'input, \.foo' must be explicit flagged :global/
+  },
+  {
+    should: 'throw on implicit global element (with multiple 2)',
+    input: '.foo, input {}',
+    error: /'\.foo, input' must be explicit flagged :global/
+  },
+  {
+    should: 'throw on implicit global attribute',
+    input: '[type="radio"] {}',
+    error: /'\[type="radio"\]' must be explicit flagged :global/
+  },
+  {
+    should: 'throw on implicit global attribute in nested',
+    input: ':not([type="radio"]) {}',
+    error: /':not\(\[type="radio"\]\)' must be explicit flagged :global/
   }
 ];