| /* |
| compiles a selector to an executable function |
| */ |
| |
| module.exports = compile; |
| |
| var parse = require("css-what"); |
| var BaseFuncs = require("boolbase"); |
| var sortRules = require("./sort.js"); |
| var procedure = require("./procedure.json"); |
| var Rules = require("./general.js"); |
| var Pseudos = require("./pseudos.js"); |
| var trueFunc = BaseFuncs.trueFunc; |
| var falseFunc = BaseFuncs.falseFunc; |
| |
| var filters = Pseudos.filters; |
| |
| function compile(selector, options, context) { |
| var next = compileUnsafe(selector, options, context); |
| return wrap(next, options); |
| } |
| |
| function wrap(next, options) { |
| var adapter = options.adapter; |
| |
| return function base(elem) { |
| return adapter.isTag(elem) && next(elem); |
| }; |
| } |
| |
| function compileUnsafe(selector, options, context) { |
| var token = parse(selector, options); |
| return compileToken(token, options, context); |
| } |
| |
| function includesScopePseudo(t) { |
| return ( |
| t.type === "pseudo" && |
| (t.name === "scope" || |
| (Array.isArray(t.data) && |
| t.data.some(function(data) { |
| return data.some(includesScopePseudo); |
| }))) |
| ); |
| } |
| |
| var DESCENDANT_TOKEN = { type: "descendant" }; |
| var FLEXIBLE_DESCENDANT_TOKEN = { type: "_flexibleDescendant" }; |
| var SCOPE_TOKEN = { type: "pseudo", name: "scope" }; |
| var PLACEHOLDER_ELEMENT = {}; |
| |
| //CSS 4 Spec (Draft): 3.3.1. Absolutizing a Scope-relative Selector |
| //http://www.w3.org/TR/selectors4/#absolutizing |
| function absolutize(token, options, context) { |
| var adapter = options.adapter; |
| |
| //TODO better check if context is document |
| var hasContext = |
| !!context && |
| !!context.length && |
| context.every(function(e) { |
| return e === PLACEHOLDER_ELEMENT || !!adapter.getParent(e); |
| }); |
| |
| token.forEach(function(t) { |
| if (t.length > 0 && isTraversal(t[0]) && t[0].type !== "descendant") { |
| //don't return in else branch |
| } else if (hasContext && !includesScopePseudo(t)) { |
| t.unshift(DESCENDANT_TOKEN); |
| } else { |
| return; |
| } |
| |
| t.unshift(SCOPE_TOKEN); |
| }); |
| } |
| |
| function compileToken(token, options, context) { |
| token = token.filter(function(t) { |
| return t.length > 0; |
| }); |
| |
| token.forEach(sortRules); |
| |
| var isArrayContext = Array.isArray(context); |
| |
| context = (options && options.context) || context; |
| |
| if (context && !isArrayContext) context = [context]; |
| |
| absolutize(token, options, context); |
| |
| var shouldTestNextSiblings = false; |
| |
| var query = token |
| .map(function(rules) { |
| if (rules[0] && rules[1] && rules[0].name === "scope") { |
| var ruleType = rules[1].type; |
| if (isArrayContext && ruleType === "descendant") { |
| rules[1] = FLEXIBLE_DESCENDANT_TOKEN; |
| } else if (ruleType === "adjacent" || ruleType === "sibling") { |
| shouldTestNextSiblings = true; |
| } |
| } |
| return compileRules(rules, options, context); |
| }) |
| .reduce(reduceRules, falseFunc); |
| |
| query.shouldTestNextSiblings = shouldTestNextSiblings; |
| |
| return query; |
| } |
| |
| function isTraversal(t) { |
| return procedure[t.type] < 0; |
| } |
| |
| function compileRules(rules, options, context) { |
| return rules.reduce(function(func, rule) { |
| if (func === falseFunc) return func; |
| |
| if (!(rule.type in Rules)) { |
| throw new Error("Rule type " + rule.type + " is not supported by css-select"); |
| } |
| |
| return Rules[rule.type](func, rule, options, context); |
| }, (options && options.rootFunc) || trueFunc); |
| } |
| |
| function reduceRules(a, b) { |
| if (b === falseFunc || a === trueFunc) { |
| return a; |
| } |
| if (a === falseFunc || b === trueFunc) { |
| return b; |
| } |
| |
| return function combine(elem) { |
| return a(elem) || b(elem); |
| }; |
| } |
| |
| function containsTraversal(t) { |
| return t.some(isTraversal); |
| } |
| |
| //:not, :has and :matches have to compile selectors |
| //doing this in lib/pseudos.js would lead to circular dependencies, |
| //so we add them here |
| filters.not = function(next, token, options, context) { |
| var opts = { |
| xmlMode: !!(options && options.xmlMode), |
| strict: !!(options && options.strict), |
| adapter: options.adapter |
| }; |
| |
| if (opts.strict) { |
| if (token.length > 1 || token.some(containsTraversal)) { |
| throw new Error("complex selectors in :not aren't allowed in strict mode"); |
| } |
| } |
| |
| var func = compileToken(token, opts, context); |
| |
| if (func === falseFunc) return next; |
| if (func === trueFunc) return falseFunc; |
| |
| return function not(elem) { |
| return !func(elem) && next(elem); |
| }; |
| }; |
| |
| filters.has = function(next, token, options) { |
| var adapter = options.adapter; |
| var opts = { |
| xmlMode: !!(options && options.xmlMode), |
| strict: !!(options && options.strict), |
| adapter: adapter |
| }; |
| |
| //FIXME: Uses an array as a pointer to the current element (side effects) |
| var context = token.some(containsTraversal) ? [PLACEHOLDER_ELEMENT] : null; |
| |
| var func = compileToken(token, opts, context); |
| |
| if (func === falseFunc) return falseFunc; |
| if (func === trueFunc) { |
| return function hasChild(elem) { |
| return adapter.getChildren(elem).some(adapter.isTag) && next(elem); |
| }; |
| } |
| |
| func = wrap(func, options); |
| |
| if (context) { |
| return function has(elem) { |
| return next(elem) && ((context[0] = elem), adapter.existsOne(func, adapter.getChildren(elem))); |
| }; |
| } |
| |
| return function has(elem) { |
| return next(elem) && adapter.existsOne(func, adapter.getChildren(elem)); |
| }; |
| }; |
| |
| filters.matches = function(next, token, options, context) { |
| var opts = { |
| xmlMode: !!(options && options.xmlMode), |
| strict: !!(options && options.strict), |
| rootFunc: next, |
| adapter: options.adapter |
| }; |
| |
| return compileToken(token, opts, context); |
| }; |
| |
| compile.compileToken = compileToken; |
| compile.compileUnsafe = compileUnsafe; |
| compile.Pseudos = Pseudos; |