index.js

var debug = require('debug')('rework-inherit')

exports = module.exports = function (options) {
  return function inherit(style) {
    return new Inherit(style, options || {})
  }
}

exports.Inherit = Inherit

function Inherit(style, options) {
  if (!(this instanceof Inherit))
    return new Inherit(style, options);

  options = options || {}

  this.propertyRegExp = options.propertyRegExp
    || /^(inherit|extend)s?$/i

  var rules = this.rules = style.rules
  this.matches = {}

  for (var i = 0; i < rules.length; i++) {
    var rule = rules[i]
    if (rule.rules) {
      // Media queries
      this.inheritMedia(rule)
      if (!rule.rules.length) rules.splice(i--, 1);
    } else if (rule.selectors) {
      // Regular rules
      this.inheritRules(rule)
      if (!rule.declarations.length) rules.splice(i--, 1);
    }
  }

  this.removePlaceholders()
}

Inherit.prototype.inheritMedia = function (mediaRule) {
  var rules = mediaRule.rules
  var query = mediaRule.media

  for (var i = 0; i < rules.length; i++) {
    var rule = rules[i]
    if (!rule.selectors) continue;

    var additionalRules = this.inheritMediaRules(rule, query)

    if (!rule.declarations.length) rules.splice(i--, 1);

    // I don't remember why I'm using apply here.
    ;[].splice.apply(rules, [i, 0].concat(additionalRules))
    i += additionalRules.length
  }
}

Inherit.prototype.inheritMediaRules = function (rule, query) {
  var declarations = rule.declarations
  var selectors = rule.selectors
  var appendRules = []

  for (var i = 0; i < declarations.length; i++) {
    var decl = declarations[i]
    // Could be comments
    if (decl.type !== 'declaration') continue;
    if (!this.propertyRegExp.test(decl.property)) continue;

    decl.value.split(',').map(trim).forEach(function (val) {
      // Should probably just use concat here
      ;[].push.apply(appendRules, this.inheritMediaRule(val, selectors, query));
    }, this)

    declarations.splice(i--, 1)
  }

  return appendRules
}

Inherit.prototype.inheritMediaRule = function (val, selectors, query) {
  var matchedRules = this.matches[val] || this.matchRules(val)
  var alreadyMatched = matchedRules.media[query]
  var matchedQueryRules = alreadyMatched || this.matchQueryRule(val, query)

  if (!matchedQueryRules.rules.length)
    throw new Error('Failed to extend as media query from ' + val + '.');

  debug('extend %j in @media %j with %j', selectors, query, val);

  this.appendSelectors(matchedQueryRules, val, selectors)

  return alreadyMatched
    ? []
    : matchedQueryRules.rules.map(getRule)
}

Inherit.prototype.inheritRules = function (rule) {
  var declarations = rule.declarations
  var selectors = rule.selectors

  for (var i = 0; i < declarations.length; i++) {
    var decl = declarations[i]
    // Could be comments
    if (decl.type !== 'declaration') continue;
    if (!this.propertyRegExp.test(decl.property)) continue;

    decl.value.split(',').map(trim).forEach(function (val) {
      this.inheritRule(val, selectors)
    }, this)

    declarations.splice(i--, 1)
  }
}

Inherit.prototype.inheritRule = function (val, selectors) {
  var matchedRules = this.matches[val] || this.matchRules(val)

  if (!matchedRules.rules.length)
    throw new Error('Failed to extend from ' + val + '.');

  debug('extend %j with %j', selectors, val);

  this.appendSelectors(matchedRules, val, selectors)
}

Inherit.prototype.matchQueryRule = function (val, query) {
  var matchedRules = this.matches[val] || this.matchRules(val)

  return matchedRules.media[query] = {
    media: query,
    rules: matchedRules.rules.map(function (rule) {
      return {
        selectors: rule.selectors,
        declarations: rule.declarations,
        rule: {
          type: 'rule',
          selectors: [],
          declarations: rule.declarations
        }
      }
    })
  }
}

Inherit.prototype.matchRules = function (val) {
  var matchedRules = this.matches[val] = {
    rules: [],
    media: {}
  }

  this.rules.forEach(function (rule) {
    if (!rule.selectors) return;

    var matchedSelectors = rule.selectors.filter(function (selector) {
      return selector.match(replaceRegExp(val))
    })

    if (!matchedSelectors.length) return;

    matchedRules.rules.push({
      selectors: matchedSelectors,
      declarations: rule.declarations,
      rule: rule
    })
  })

  return matchedRules
}

Inherit.prototype.appendSelectors = function (matchedRules, val, selectors) {
  matchedRules.rules.forEach(function (matchedRule) {
    // Selector to actually inherit
    var selectorReference = matchedRule.rule.selectors

    matchedRule.selectors.forEach(function (matchedSelector) {
      ;[].push.apply(selectorReference, selectors.map(function (selector) {
        return replaceSelector(matchedSelector, val, selector)
      }))
    })
  })
}

// Placeholders are not allowed in media queries
Inherit.prototype.removePlaceholders = function () {
  var rules = this.rules

  for (var i = 0; i < rules.length; i++) {
    var selectors = rules[i].selectors
    if (!selectors) continue;

    for (var j = 0; j < selectors.length; j++) {
      var selector = selectors[j]
      if (~selector.indexOf('%')) selectors.splice(j--, 1);
    }

    if (!selectors.length) rules.splice(i--, 1);
  }
}

function replaceSelector(matchedSelector, val, selector) {
  return matchedSelector.replace(replaceRegExp(val), function (_, first, last) {
    return first + selector + last
  })
}

function isPlaceholder(val) {
  return val[0] === '%';
}

function replaceRegExp(val) {
  var expression = escapeRegExp(val) + '($|\\s|\\>|\\+|~|\\:|\\[)';
  var expressionPrefix = '(^|\\s|\\>|\\+|~)';
  if (isPlaceholder(val)) {
    // We just want to match an empty group here to preserve the arguments we
    // may be expecting in a RegExp match.
    expressionPrefix = '()';
  }
  return new RegExp(expressionPrefix + expression, 'g');
}

function escapeRegExp(str) {
  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
}

function trim(x) {
  return x.trim()
}

function getRule(x) {
  return x.rule
}