sassc 2.2.1 → 2.3.0

data/ext/libsass/src/ast_sel_super.cpp

@@ -0,0 +1,539 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include "ast.hpp"
+
+#include "util_string.hpp"
+
+namespace Sass {
+
+  // ##########################################################################
+  // To compare/debug against libsass you can use debugger.hpp:
+  // c++: std::cerr << "result " << debug_vec(compound) << "\n";
+  // dart: stderr.writeln("result " + compound.toString());
+  // ##########################################################################
+
+  // ##########################################################################
+  // Returns whether [list1] is a superselector of [list2].
+  // That is, whether [list1] matches every element that
+  // [list2] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool listIsSuperslector(
+    const std::vector<ComplexSelectorObj>& list1,
+    const std::vector<ComplexSelectorObj>& list2);
+
+  // ##########################################################################
+  // Returns whether [complex1] is a superselector of [complex2].
+  // That is, whether [complex1] matches every element that
+  // [complex2] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool complexIsSuperselector(
+    const std::vector<SelectorComponentObj>& complex1,
+    const std::vector<SelectorComponentObj>& complex2);
+
+  // ##########################################################################
+  // Returns all pseudo selectors in [compound] that have
+  // a selector argument, and that have the given [name].
+  // ##########################################################################
+  std::vector<Pseudo_Selector_Obj> selectorPseudoNamed(
+    CompoundSelectorObj compound, std::string name)
+  {
+    std::vector<Pseudo_Selector_Obj> rv;
+    for (SimpleSelectorObj sel : compound->elements()) {
+      if (Pseudo_Selector_Obj pseudo = Cast<Pseudo_Selector>(sel)) {
+        if (pseudo->isClass() && pseudo->selector()) {
+          if (sel->name() == name) {
+            rv.push_back(sel);
+          }
+        }
+      }
+    }
+    return rv;
+  }
+  // EO selectorPseudoNamed
+
+  // ##########################################################################
+  // Returns whether [simple1] is a superselector of [simple2].
+  // That is, whether [simple1] matches every element that
+  // [simple2] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool simpleIsSuperselector(
+    const SimpleSelectorObj& simple1,
+    const SimpleSelectorObj& simple2)
+  {
+    // If they are equal they are superselectors
+    if (ObjEqualityFn(simple1, simple2)) {
+      return true;
+    }
+    // Some selector pseudoclasses can match normal selectors.
+    if (const Pseudo_Selector* pseudo = Cast<Pseudo_Selector>(simple2)) {
+      if (pseudo->selector() && isSubselectorPseudo(pseudo->normalized())) {
+        for (auto complex : pseudo->selector()->elements()) {
+          // Make sure we have exacly one items
+          if (complex->length() != 1) {
+            return false;
+          }
+          // That items must be a compound selector
+          if (auto compound = Cast<CompoundSelector>(complex->at(0))) {
+            // It must contain the lhs simple selector
+            if (!compound->contains(simple1)) { 
+              return false;
+            }
+          }
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  // EO simpleIsSuperselector
+
+  // ##########################################################################
+  // Returns whether [simple] is a superselector of [compound].
+  // That is, whether [simple] matches every element that
+  // [compound] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool simpleIsSuperselectorOfCompound(
+    const SimpleSelectorObj& simple,
+    const CompoundSelectorObj& compound)
+  {
+    for (SimpleSelectorObj simple2 : compound->elements()) {
+      if (simpleIsSuperselector(simple, simple2)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // EO simpleIsSuperselectorOfCompound
+
+  // ##########################################################################
+  // ##########################################################################
+  bool typeIsSuperselectorOfCompound(
+    const Type_Selector_Obj& type,
+    const CompoundSelectorObj& compound)
+  {
+    for (const SimpleSelectorObj& simple : compound->elements()) {
+      if (const Type_Selector_Obj& rhs = Cast<Type_Selector>(simple)) {
+        if (*type != *rhs) return true;
+      }
+    }
+    return false;
+  }
+  // EO typeIsSuperselectorOfCompound
+
+  // ##########################################################################
+  // ##########################################################################
+  bool idIsSuperselectorOfCompound(
+    const Id_Selector_Obj& id,
+    const CompoundSelectorObj& compound)
+  {
+    for (const SimpleSelectorObj& simple : compound->elements()) {
+      if (const Id_Selector_Obj& rhs = Cast<Id_Selector>(simple)) {
+        if (*id != *rhs) return true;
+      }
+    }
+    return false;
+  }
+  // EO idIsSuperselectorOfCompound
+
+  // ##########################################################################
+  // ##########################################################################
+  bool pseudoIsSuperselectorOfPseudo(
+    const Pseudo_Selector_Obj& pseudo1,
+    const Pseudo_Selector_Obj& pseudo2,
+    const ComplexSelectorObj& parent
+  )
+  {
+    if (!pseudo2->selector()) return false;
+    if (pseudo1->name() == pseudo2->name()) {
+      SelectorListObj list = pseudo2->selector();
+      return listIsSuperslector(list->elements(), { parent });
+    }
+    return false;
+  }
+  // EO pseudoIsSuperselectorOfPseudo
+
+  // ##########################################################################
+  // ##########################################################################
+  bool pseudoNotIsSuperselectorOfCompound(
+    const Pseudo_Selector_Obj& pseudo1,
+    const CompoundSelectorObj& compound2,
+    const ComplexSelectorObj& parent)
+  {
+    for (const SimpleSelectorObj& simple2 : compound2->elements()) {
+      if (const Type_Selector_Obj& type2 = Cast<Type_Selector>(simple2)) {
+        if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
+          if (typeIsSuperselectorOfCompound(type2, compound1)) return true;
+        }
+      }
+      else if (const Id_Selector_Obj& id2 = Cast<Id_Selector>(simple2)) {
+        if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
+          if (idIsSuperselectorOfCompound(id2, compound1)) return true;
+        }
+      }
+      else if (const Pseudo_Selector_Obj& pseudo2 = Cast<Pseudo_Selector>(simple2)) {
+        if (pseudoIsSuperselectorOfPseudo(pseudo1, pseudo2, parent)) return true;
+      }
+    }
+    return false;
+  }
+  // pseudoNotIsSuperselectorOfCompound
+
+  // ##########################################################################
+  // Returns whether [pseudo1] is a superselector of [compound2].
+  // That is, whether [pseudo1] matches every element that [compound2]
+  // matches, as well as possibly additional elements. This assumes that
+  // [pseudo1]'s `selector` argument is not `null`. If [parents] is passed,
+  // it represents the parents of [compound2]. This is relevant for pseudo
+  // selectors with selector arguments, where we may need to know if the
+  // parent selectors in the selector argument match [parents].
+  // ##########################################################################
+  bool selectorPseudoIsSuperselector(
+    const Pseudo_Selector_Obj& pseudo1,
+    const CompoundSelectorObj& compound2,
+    // ToDo: is this really the most convenient way to do this?
+    std::vector<SelectorComponentObj>::const_iterator parents_from,
+    std::vector<SelectorComponentObj>::const_iterator parents_to)
+  {
+
+    // ToDo: move normalization function
+    std::string name(Util::unvendor(pseudo1->name()));
+
+    if (name == "matches" || name == "any") {
+      std::vector<Pseudo_Selector_Obj> pseudos =
+        selectorPseudoNamed(compound2, pseudo1->name());
+      SelectorListObj selector1 = pseudo1->selector();
+      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+        SelectorListObj selector = pseudo2->selector();
+        if (selector1->isSuperselectorOf(selector)) {
+          return true;
+        }
+      }
+
+      for (ComplexSelectorObj complex1 : selector1->elements()) {
+        std::vector<SelectorComponentObj> parents;
+        for (auto cur = parents_from; cur != parents_to; cur++) {
+          parents.push_back(*cur);
+        }
+        parents.push_back(compound2);
+        if (complexIsSuperselector(complex1->elements(), parents)) {
+          return true;
+        }
+      }
+
+    }
+    else if (name == "has" || name == "host" || name == "host-context" || name == "slotted") {
+      std::vector<Pseudo_Selector_Obj> pseudos =
+        selectorPseudoNamed(compound2, pseudo1->name());
+      SelectorListObj selector1 = pseudo1->selector();
+      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+        SelectorListObj selector = pseudo2->selector();
+        if (selector1->isSuperselectorOf(selector)) {
+          return true;
+        }
+      }
+
+    }
+    else if (name == "not") {
+      for (ComplexSelectorObj complex : pseudo1->selector()->elements()) {
+        if (!pseudoNotIsSuperselectorOfCompound(pseudo1, compound2, complex)) return false;
+      }
+      return true;
+    }
+    else if (name == "current") {
+      std::vector<Pseudo_Selector_Obj> pseudos =
+        selectorPseudoNamed(compound2, "current");
+      for (Pseudo_Selector_Obj pseudo2 : pseudos) {
+        if (ObjEqualityFn(pseudo1, pseudo2)) return true;
+      }
+
+    }
+    else if (name == "nth-child" || name == "nth-last-child") {
+      for (auto simple2 : compound2->elements()) {
+        if (Pseudo_Selector_Obj pseudo2 = simple2->getPseudoSelector()) {
+          if (pseudo1->name() != pseudo2->name()) continue;
+          if (!ObjEqualityFn(pseudo1->argument(), pseudo2->argument())) continue;
+          if (pseudo1->selector()->isSuperselectorOf(pseudo2->selector())) return true;
+        }
+      }
+      return false;
+    }
+
+    return false;
+
+  }
+  // EO selectorPseudoIsSuperselector
+
+  // ##########################################################################
+  // Returns whether [compound1] is a superselector of [compound2].
+  // That is, whether [compound1] matches every element that [compound2]
+  // matches, as well as possibly additional elements. If [parents] is
+  // passed, it represents the parents of [compound2]. This is relevant
+  // for pseudo selectors with selector arguments, where we may need to
+  // know if the parent selectors in the selector argument match [parents].
+  // ##########################################################################
+  bool compoundIsSuperselector(
+    const CompoundSelectorObj& compound1,
+    const CompoundSelectorObj& compound2,
+    // ToDo: is this really the most convenient way to do this?
+    const std::vector<SelectorComponentObj>::const_iterator parents_from,
+    const std::vector<SelectorComponentObj>::const_iterator parents_to)
+  {
+    // Every selector in [compound1.components] must have
+    // a matching selector in [compound2.components].
+    for (SimpleSelectorObj simple1 : compound1->elements()) {
+      Pseudo_Selector_Obj pseudo1 = Cast<Pseudo_Selector>(simple1);
+      if (pseudo1 && pseudo1->selector()) {
+        if (!selectorPseudoIsSuperselector(pseudo1, compound2, parents_from, parents_to)) {
+          return false;
+        }
+      }
+      else if (!simpleIsSuperselectorOfCompound(simple1, compound2)) {
+        return false;
+      }
+    }
+    // [compound1] can't be a superselector of a selector
+    // with pseudo-elements that [compound2] doesn't share.
+    for (SimpleSelectorObj simple2 : compound2->elements()) {
+      Pseudo_Selector_Obj pseudo2 = Cast<Pseudo_Selector>(simple2);
+      if (pseudo2 && pseudo2->isElement()) {
+        if (!simpleIsSuperselectorOfCompound(pseudo2, compound1)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  // EO compoundIsSuperselector
+
+  // ##########################################################################
+  // Returns whether [compound1] is a superselector of [compound2].
+  // That is, whether [compound1] matches every element that [compound2]
+  // matches, as well as possibly additional elements. If [parents] is
+  // passed, it represents the parents of [compound2]. This is relevant
+  // for pseudo selectors with selector arguments, where we may need to
+  // know if the parent selectors in the selector argument match [parents].
+  // ##########################################################################
+  bool compoundIsSuperselector(
+    const CompoundSelectorObj& compound1,
+    const CompoundSelectorObj& compound2,
+    const std::vector<SelectorComponentObj>& parents)
+  {
+    return compoundIsSuperselector(
+      compound1, compound2,
+      parents.begin(), parents.end()
+    );
+  }
+  // EO compoundIsSuperselector
+
+  // ##########################################################################
+  // Returns whether [complex1] is a superselector of [complex2].
+  // That is, whether [complex1] matches every element that
+  // [complex2] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool complexIsSuperselector(
+    const std::vector<SelectorComponentObj>& complex1,
+    const std::vector<SelectorComponentObj>& complex2)
+  {
+
+    // Selectors with trailing operators are neither superselectors nor subselectors.
+    if (!complex1.empty() && Cast<SelectorCombinator>(complex1.back())) return false;
+    if (!complex2.empty() && Cast<SelectorCombinator>(complex2.back())) return false;
+
+    size_t i1 = 0, i2 = 0;
+    while (true) {
+
+      size_t remaining1 = complex1.size() - i1;
+      size_t remaining2 = complex2.size() - i2;
+
+      if (remaining1 == 0 || remaining2 == 0) {
+        return false;
+      }
+      // More complex selectors are never
+      // superselectors of less complex ones.
+      if (remaining1 > remaining2) {
+        return false;
+      }
+
+      // Selectors with leading operators are
+      // neither superselectors nor subselectors.
+      if (Cast<SelectorCombinator>(complex1[i1])) {
+        return false;
+      }
+      if (Cast<SelectorCombinator>(complex2[i2])) {
+        return false;
+      }
+
+      CompoundSelectorObj compound1 = Cast<CompoundSelector>(complex1[i1]);
+      CompoundSelectorObj compound2 = Cast<CompoundSelector>(complex2.back());
+
+      if (remaining1 == 1) {
+        std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.end();
+        std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
+        std::advance(parents_from, i2 + 1); // equivalent to dart `.skip(i2 + 1)`
+        bool rv = compoundIsSuperselector(compound1, compound2, parents_from, parents_to);
+        std::vector<SelectorComponentObj> pp;
+
+        std::vector<SelectorComponentObj>::const_iterator end = parents_to;
+        std::vector<SelectorComponentObj>::const_iterator beg = parents_from;
+        while (beg != end) {
+          pp.push_back(*beg);
+          beg++;
+        }
+
+        return rv;
+      }
+
+      // Find the first index where `complex2.sublist(i2, afterSuperselector)`
+      // is a subselector of [compound1]. We stop before the superselector
+      // would encompass all of [complex2] because we know [complex1] has 
+      // more than one element, and consuming all of [complex2] wouldn't 
+      // leave anything for the rest of [complex1] to match.
+      size_t afterSuperselector = i2 + 1;
+      for (; afterSuperselector < complex2.size(); afterSuperselector++) {
+        SelectorComponentObj component2 = complex2[afterSuperselector - 1];
+        if (CompoundSelectorObj compound2 = Cast<CompoundSelector>(component2)) {
+          std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.begin();
+          std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
+          // complex2.take(afterSuperselector - 1).skip(i2 + 1)
+          std::advance(parents_from, i2 + 1); // equivalent to dart `.skip`
+          std::advance(parents_to, afterSuperselector); // equivalent to dart `.take`
+          if (compoundIsSuperselector(compound1, compound2, parents_from, parents_to)) {
+            break;
+          }
+        }
+      }
+      if (afterSuperselector == complex2.size()) {
+        return false;
+      }
+
+      SelectorComponentObj component1 = complex1[i1 + 1],
+        component2 = complex2[afterSuperselector];
+
+      SelectorCombinatorObj combinator1 = Cast<SelectorCombinator>(component1);
+      SelectorCombinatorObj combinator2 = Cast<SelectorCombinator>(component2);
+
+      if (!combinator1.isNull()) {
+
+        if (combinator2.isNull()) {
+          return false;
+        }
+        // `.a ~ .b` is a superselector of `.a + .b`,
+        // but otherwise the combinators must match.
+        if (combinator1->isGeneralCombinator()) {
+          if (combinator2->isChildCombinator()) {
+            return false;
+          }
+        }
+        else if (*combinator1 != *combinator2) {
+          return false;
+        }
+
+        // `.foo > .baz` is not a superselector of `.foo > .bar > .baz` or
+        // `.foo > .bar .baz`, despite the fact that `.baz` is a superselector of
+        // `.bar > .baz` and `.bar .baz`. Same goes for `+` and `~`.
+        if (remaining1 == 3 && remaining2 > 3) {
+          return false;
+        }
+
+        i1 += 2; i2 = afterSuperselector + 1;
+
+      }
+      else if (!combinator2.isNull()) {
+        if (!combinator2->isChildCombinator()) {
+          return false;
+        }
+        i1 += 1; i2 = afterSuperselector + 1;
+      }
+      else {
+        i1 += 1; i2 = afterSuperselector;
+      }
+    }
+
+    return false;
+
+  }
+  // EO complexIsSuperselector
+
+  // ##########################################################################
+  // Like [complexIsSuperselector], but compares [complex1]
+  // and [complex2] as though they shared an implicit base
+  // [SimpleSelector]. For example, `B` is not normally a
+  // superselector of `B A`, since it doesn't match elements
+  // that match `A`. However, it *is* a parent superselector,
+  // since `B X` is a superselector of `B A X`.
+  // ##########################################################################
+  bool complexIsParentSuperselector(
+    const std::vector<SelectorComponentObj>& complex1,
+    const std::vector<SelectorComponentObj>& complex2)
+  {
+    // Try some simple heuristics to see if we can avoid allocations.
+    if (complex1.empty() && complex2.empty()) return false;
+    if (Cast<SelectorCombinator>(complex1.front())) return false;
+    if (Cast<SelectorCombinator>(complex2.front())) return false;
+    if (complex1.size() > complex2.size()) return false;
+    // TODO(nweiz): There's got to be a way to do this without a bunch of extra allocations...
+    std::vector<SelectorComponentObj> cplx1(complex1);
+    std::vector<SelectorComponentObj> cplx2(complex2);
+    CompoundSelectorObj base = SASS_MEMORY_NEW(CompoundSelector, "[tmp]");
+    cplx1.push_back(base); cplx2.push_back(base);
+    return complexIsSuperselector(cplx1, cplx2);
+  }
+  // EO complexIsParentSuperselector
+
+  // ##########################################################################
+  // Returns whether [list] has a superselector for [complex].
+  // That is, whether an item in [list] matches every element that
+  // [complex] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool listHasSuperslectorForComplex(
+    std::vector<ComplexSelectorObj> list,
+    ComplexSelectorObj complex)
+  {
+    // Return true if every [complex] selector on [list2]
+    // is a super selector of the full selector [list1].
+    for (ComplexSelectorObj lhs : list) {
+      if (complexIsSuperselector(lhs->elements(), complex->elements())) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // listIsSuperslectorOfComplex
+
+  // ##########################################################################
+  // Returns whether [list1] is a superselector of [list2].
+  // That is, whether [list1] matches every element that
+  // [list2] matches, as well as possibly additional elements.
+  // ##########################################################################
+  bool listIsSuperslector(
+    const std::vector<ComplexSelectorObj>& list1,
+    const std::vector<ComplexSelectorObj>& list2)
+  {
+    // Return true if every [complex] selector on [list2]
+    // is a super selector of the full selector [list1].
+    for (ComplexSelectorObj complex : list2) {
+      if (!listHasSuperslectorForComplex(list1, complex)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // EO listIsSuperslector
+
+  // ##########################################################################
+  // Implement selector methods (dispatch to functions)
+  // ##########################################################################
+  bool SelectorList::isSuperselectorOf(const SelectorList* sub) const
+  {
+    return listIsSuperslector(elements(), sub->elements());
+  }
+  bool ComplexSelector::isSuperselectorOf(const ComplexSelector* sub) const
+  {
+    return complexIsSuperselector(elements(), sub->elements());
+  }
+
+  // ##########################################################################
+  // ##########################################################################
+
+}