add prop list

index.js

@@ -2,6 +2,7 @@
 
 var postcss = require('postcss');
 var objectAssign = require('object-assign');
+var { createPropListMatcher } = require('./src/prop-list-matcher');
 
 var defaults = {
   unitToConvert: 'px',
@@ -11,6 +12,7 @@ var defaults = {
   viewportUnit: 'vw',
   fontViewportUnit: 'vw',  // vmin is more suitable.
   selectorBlackList: [],
+  propList: ['*'],
   minPixelValue: 1,
   mediaQuery: false
 };
@@ -27,14 +29,16 @@ module.exports = postcss.plugin('postcss-px-to-viewport', function (options) {
   // Any digit followed by px
   // !singlequotes|!doublequotes|!url()|pixelunit
   var pxRegex = new RegExp('"[^"]+"|\'[^\']+\'|url\\([^\\)]+\\)|(\\d*\\.?\\d+)' + opts.unitToConvert, 'ig')
+  var satisfyPropList = createPropListMatcher(opts.propList);
 
   return function (css) {
 
     css.walkDecls(function (decl, i) {
-      // This should be the fastest test and will remove most declarations
-      if (decl.value.indexOf(opts.unitToConvert) === -1) return;
-
-      if (blacklistedSelector(opts.selectorBlackList, decl.parent.selector)) return;
+      if (
+        decl.value.indexOf(opts.unitToConvert) === -1 ||
+        !satisfyPropList(decl.prop) || 
+        blacklistedSelector(opts.selectorBlackList, decl.parent.selector)
+       ) return;
 
       var unit = getUnit(decl.prop, opts)
 

spec/px-to-viewport.spec.js

@@ -9,6 +9,7 @@
 var postcss = require('postcss');
 var pxToViewport = require('..');
 var basicCSS = '.rule { font-size: 15px }';
+var { filterPropList } = require('../src/prop-list-matcher');
 
 describe('px-to-viewport', function() {
   it('should work on the readme example', function () {
@@ -196,3 +197,53 @@ describe('minPixelValue', function () {
       expect(processed).toBe(expected);
   });
 });
+
+describe('filter-prop-list', function () {
+  it('should find "exact" matches from propList', function () {
+      var propList = ['font-size', 'margin', '!padding', '*border*', '*', '*y', '!*font*'];
+      var expected = 'font-size,margin';
+      expect(filterPropList.exact(propList).join()).toBe(expected);
+  });
+
+  it('should find "contain" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', '*border*', '*', '*y', '!*font*'];
+      var expected = 'margin,border';
+      expect(filterPropList.contain(propList).join()).toBe(expected);
+  });
+
+  it('should find "start" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', 'border*', '*', '*y', '!*font*'];
+      var expected = 'border';
+      expect(filterPropList.startWith(propList).join()).toBe(expected);
+  });
+
+  it('should find "end" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', 'border*', '*', '*y', '!*font*'];
+      var expected = 'y';
+      expect(filterPropList.endWith(propList).join()).toBe(expected);
+  });
+
+  it('should find "not" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', 'border*', '*', '*y', '!*font*'];
+      var expected = 'padding';
+      expect(filterPropList.notExact(propList).join()).toBe(expected);
+  });
+
+  it('should find "not contain" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', '!border*', '*', '*y', '!*font*'];
+      var expected = 'font';
+      expect(filterPropList.notContain(propList).join()).toBe(expected);
+  });
+
+  it('should find "not start" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', '!border*', '*', '*y', '!*font*'];
+      var expected = 'border';
+      expect(filterPropList.notStartWith(propList).join()).toBe(expected);
+  });
+
+  it('should find "not end" matches from propList and reduce to string', function () {
+      var propList = ['font-size', '*margin*', '!padding', '!border*', '*', '!*y', '!*font*'];
+      var expected = 'y';
+      expect(filterPropList.notEndWith(propList).join()).toBe(expected);
+  });
+});

src/prop-list-matcher.js

@@ -0,0 +1,106 @@
+var filterPropList = {
+  exact: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^[^\*\!]+$/);
+      });
+  },
+  contain: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\*.+\*$/);
+      }).map(function (m) {
+          return m.substr(1, m.length - 2);
+      });
+  },
+  endWith: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\*[^\*]+$/);
+      }).map(function (m) {
+          return m.substr(1);
+      });
+  },
+  startWith: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^[^\*\!]+\*$/);
+      }).map(function (m) {
+          return m.substr(0, m.length - 1);
+      });
+  },
+  notExact: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\![^\*].*$/);
+      }).map(function (m) {
+          return m.substr(1);
+      });
+  },
+  notContain: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\!\*.+\*$/);
+      }).map(function (m) {
+          return m.substr(2, m.length - 3);
+      });
+  },
+  notEndWith: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\!\*[^\*]+$/);
+      }).map(function (m) {
+          return m.substr(2);
+      });
+  },
+  notStartWith: function (list) {
+      return list.filter(function (m) {
+          return m.match(/^\![^\*]+\*$/);
+      }).map(function (m) {
+          return m.substr(1, m.length - 2);
+      });
+  }
+};
+
+function createPropListMatcher(propList) {
+  var hasWild = propList.indexOf('*') > -1;
+  var matchAll = (hasWild && propList.length === 1);
+  var lists = {
+      exact: filterPropList.exact(propList),
+      contain: filterPropList.contain(propList),
+      startWith: filterPropList.startWith(propList),
+      endWith: filterPropList.endWith(propList),
+      notExact: filterPropList.notExact(propList),
+      notContain: filterPropList.notContain(propList),
+      notStartWith: filterPropList.notStartWith(propList),
+      notEndWith: filterPropList.notEndWith(propList)
+  };
+  return function (prop) {
+      if (matchAll) return true;
+      return (
+          (
+              hasWild ||
+              lists.exact.indexOf(prop) > -1 ||
+              lists.contain.some(function (m) {
+                  return prop.indexOf(m) > -1;
+              }) ||
+              lists.startWith.some(function (m) {
+                  return prop.indexOf(m) === 0;
+              }) ||
+              lists.endWith.some(function (m) {
+                  return prop.indexOf(m) === prop.length - m.length;
+              })
+          ) &&
+          !(
+              lists.notExact.indexOf(prop) > -1 ||
+              lists.notContain.some(function (m) {
+                  return prop.indexOf(m) > -1;
+              }) ||
+              lists.notStartWith.some(function (m) {
+                  return prop.indexOf(m) === 0;
+              }) ||
+              lists.notEndWith.some(function (m) {
+                  return prop.indexOf(m) === prop.length - m.length;
+              })
+          )
+      );
+  };
+}
+
+module.exports = {
+    filterPropList,
+    createPropListMatcher
+};