sassc 2.2.1 → 2.3.0

data/ext/libsass/src/ast_def_macros.hpp

@@ -101,6 +101,14 @@ private:
 
 #endif
 
+#define ATTACH_VIRTUAL_CMP_OPERATIONS(klass) \
+  virtual bool operator==(const klass& rhs) const = 0; \
+  virtual bool operator!=(const klass& rhs) const { return !(*this == rhs); }; \
+
+#define ATTACH_CMP_OPERATIONS(klass) \
+  virtual bool operator==(const klass& rhs) const; \
+  virtual bool operator!=(const klass& rhs) const { return !(*this == rhs); }; \
+
 #ifdef DEBUG_SHARED_PTR
 
   #define IMPLEMENT_AST_OPERATORS(klass) \

data/ext/libsass/src/ast_fwd_decl.cpp

@@ -25,6 +25,7 @@ namespace Sass {
   IMPLEMENT_BASE_CAST(String_Constant)
   IMPLEMENT_BASE_CAST(Supports_Condition)
   IMPLEMENT_BASE_CAST(Selector)
-  IMPLEMENT_BASE_CAST(Simple_Selector)
+  IMPLEMENT_BASE_CAST(SelectorComponent)
+  IMPLEMENT_BASE_CAST(SimpleSelector)
 
 }

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -1,17 +1,12 @@
 #ifndef SASS_AST_FWD_DECL_H
 #define SASS_AST_FWD_DECL_H
 
-#include <map>
-#include <set>
-#include <deque>
-#include <vector>
-#include <typeinfo>
-#include <iostream>
-#include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
-#include "memory/SharedPtr.hpp"
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include "sass/functions.h"
+#include "memory/SharedPtr.hpp"
 
 /////////////////////////////////////////////
 // Forward declarations for the AST visitors.
@@ -22,7 +17,7 @@ namespace Sass {
 
   class Has_Block;
 
-  class Simple_Selector;
+  class SimpleSelector;
 
   class Parent_Reference;
 
@@ -36,11 +31,13 @@ namespace Sass {
   class Bubble;
   class Trace;
 
-  class Media_Block;
+  class MediaRule;
+  class CssMediaRule;
+  class CssMediaQuery;
+
   class Supports_Block;
   class Directive;
 
-
   class Keyframe_Rule;
   class At_Root_Block;
   class Assignment;
@@ -59,7 +56,7 @@ namespace Sass {
   class While;
   class Return;
   class Content;
-  class Extension;
+  class ExtendRule;
   class Definition;
 
   class List;
@@ -80,6 +77,7 @@ namespace Sass {
   class Color_HSLA;
   class Boolean;
   class String;
+  class Null;
 
   class String_Schema;
   class String_Constant;
@@ -92,12 +90,8 @@ namespace Sass {
   class Supports_Negation;
   class Supports_Declaration;
   class Supports_Interpolation;
-
-
-  class Null;
-
+  
   class At_Root_Query;
-  class Parent_Selector;
   class Parameter;
   class Parameters;
   class Argument;
@@ -113,20 +107,26 @@ namespace Sass {
   class Attribute_Selector;
 
   class Pseudo_Selector;
-  class Wrapped_Selector;
-  class Compound_Selector;
-  class Complex_Selector;
-  class Selector_List;
-
+  
+  class SelectorComponent;
+  class SelectorCombinator;
+  class CompoundSelector;
+  class ComplexSelector;
+  class SelectorList;
 
   // common classes
   class Context;
   class Expand;
   class Eval;
 
+  class Extension;
+
   // declare classes that are instances of memory nodes
-  // #define IMPL_MEM_OBJ(type) using type##_Obj = SharedImpl<type>
-  #define IMPL_MEM_OBJ(type) typedef SharedImpl<type> type##_Obj
+  // Note: also add a mapping without underscore
+  // ToDo: move to camelCase vars in the future
+  #define IMPL_MEM_OBJ(type) \
+    typedef SharedImpl<type> type##Obj; \
+    typedef SharedImpl<type> type##_Obj; \
 
   IMPL_MEM_OBJ(AST_Node);
   IMPL_MEM_OBJ(Statement);
@@ -134,7 +134,9 @@ namespace Sass {
   IMPL_MEM_OBJ(Ruleset);
   IMPL_MEM_OBJ(Bubble);
   IMPL_MEM_OBJ(Trace);
-  IMPL_MEM_OBJ(Media_Block);
+  IMPL_MEM_OBJ(MediaRule);
+  IMPL_MEM_OBJ(CssMediaRule);
+  IMPL_MEM_OBJ(CssMediaQuery);
   IMPL_MEM_OBJ(Supports_Block);
   IMPL_MEM_OBJ(Directive);
   IMPL_MEM_OBJ(Keyframe_Rule);
@@ -155,7 +157,7 @@ namespace Sass {
   IMPL_MEM_OBJ(While);
   IMPL_MEM_OBJ(Return);
   IMPL_MEM_OBJ(Content);
-  IMPL_MEM_OBJ(Extension);
+  IMPL_MEM_OBJ(ExtendRule);
   IMPL_MEM_OBJ(Definition);
   IMPL_MEM_OBJ(Mixin_Call);
   IMPL_MEM_OBJ(Value);
@@ -187,7 +189,6 @@ namespace Sass {
   IMPL_MEM_OBJ(Supports_Interpolation);
   IMPL_MEM_OBJ(At_Root_Query);
   IMPL_MEM_OBJ(Null);
-  IMPL_MEM_OBJ(Parent_Selector);
   IMPL_MEM_OBJ(Parent_Reference);
   IMPL_MEM_OBJ(Parameter);
   IMPL_MEM_OBJ(Parameters);
@@ -195,107 +196,29 @@ namespace Sass {
   IMPL_MEM_OBJ(Arguments);
   IMPL_MEM_OBJ(Selector);
   IMPL_MEM_OBJ(Selector_Schema);
-  IMPL_MEM_OBJ(Simple_Selector);
+  IMPL_MEM_OBJ(SimpleSelector);
   IMPL_MEM_OBJ(Placeholder_Selector);
   IMPL_MEM_OBJ(Type_Selector);
   IMPL_MEM_OBJ(Class_Selector);
   IMPL_MEM_OBJ(Id_Selector);
   IMPL_MEM_OBJ(Attribute_Selector);
   IMPL_MEM_OBJ(Pseudo_Selector);
-  IMPL_MEM_OBJ(Wrapped_Selector);
-  IMPL_MEM_OBJ(Compound_Selector);
-  IMPL_MEM_OBJ(Complex_Selector);
-  IMPL_MEM_OBJ(Selector_List);
 
-  // ###########################################################################
-  // Implement compare, order and hashing operations for AST Nodes
-  // ###########################################################################
-
-  struct HashNodes {
-    template <class T>
-    size_t operator() (const T& ex) const {
-      return ex.isNull() ? 0 : ex->hash();
-    }
-  };
-  template <class T>
-  bool OrderFunction(const T& lhs, const T& rhs) {
-      return !lhs.isNull() && !rhs.isNull() && *lhs < *rhs;
-  };
-  struct OrderNodes {
-    template <class T>
-    bool operator() (const T& lhs, const T& rhs) const {
-      return OrderFunction<T>(lhs, rhs);
-    }
-  };
-  template <class T>
-  bool CompareFunction(const T& lhs, const T& rhs) {
-      // code around sass logic issue. 1px == 1 is true
-      // but both items are still different keys in maps
-      if (dynamic_cast<Number*>(lhs.ptr()))
-        if (dynamic_cast<Number*>(rhs.ptr()))
-          return lhs->hash() == rhs->hash();
-      return !lhs.isNull() && !rhs.isNull() && *lhs == *rhs;
-  }
-  struct CompareNodes {
-    template <class T>
-    bool operator() (const T& lhs, const T& rhs) const {
-      return CompareFunction<T>(lhs, rhs);
-    }
-  };
-
-  struct HashPtr {
-    template <class T>
-    size_t operator() (const T *ref) const {
-      return ref->hash();
-    }
-  };
-  struct ComparePtrs {
-    template <class T>
-    bool operator() (const T *lhs, const T *rhs) const {
-      return *lhs == *rhs;
-    }
-  };
+  IMPL_MEM_OBJ(SelectorComponent);
+  IMPL_MEM_OBJ(SelectorCombinator);
+  IMPL_MEM_OBJ(CompoundSelector);
+  IMPL_MEM_OBJ(ComplexSelector);
+  IMPL_MEM_OBJ(SelectorList);
 
   // ###########################################################################
   // some often used typedefs
   // ###########################################################################
 
-  typedef std::unordered_map<
-    Expression_Obj, // key
-    Expression_Obj, // value
-    HashNodes, // hasher
-    CompareNodes // compare
-  > ExpressionMap;
-  typedef std::unordered_set<
-    Expression_Obj, // value
-    HashNodes, // hasher
-    CompareNodes // compare
-  > ExpressionSet;
-
-  typedef std::string SubSetMapKey;
-  typedef std::vector<std::string> SubSetMapKeys;
-
-  typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> SubSetMapPair;
-  typedef std::pair<Compound_Selector_Obj, Complex_Selector_Obj> SubSetMapLookup;
-  typedef std::vector<SubSetMapPair> SubSetMapPairs;
-  typedef std::vector<SubSetMapLookup> SubSetMapLookups;
-
-  typedef std::pair<Complex_Selector_Obj, SubSetMapPairs> SubSetMapResult;
-  typedef std::vector<SubSetMapResult> SubSetMapResults;
-
-  typedef std::set<Selector_Obj, OrderNodes> SelectorSet;
-
-  typedef std::deque<Complex_Selector_Obj> ComplexSelectorDeque;
-  typedef std::set<Simple_Selector_Obj, OrderNodes> SimpleSelectorSet;
-  typedef std::set<Complex_Selector_Obj, OrderNodes> ComplexSelectorSet;
-  typedef std::set<Compound_Selector_Obj, OrderNodes> CompoundSelectorSet;
-  typedef std::unordered_set<Simple_Selector_Obj, HashNodes, CompareNodes> SimpleSelectorDict;
-
   typedef std::vector<Block*> BlockStack;
   typedef std::vector<Sass_Callee> CalleeStack;
   typedef std::vector<AST_Node_Obj> CallStack;
-  typedef std::vector<Media_Block*> MediaStack;
-  typedef std::vector<Selector_List_Obj> SelectorStack;
+  typedef std::vector<CssMediaRuleObj> MediaStack;
+  typedef std::vector<SelectorListObj> SelectorStack;
   typedef std::vector<Sass_Import_Entry> ImporterStack;
 
   // only to switch implementations for testing
@@ -334,7 +257,8 @@ namespace Sass {
   DECLARE_BASE_CAST(String_Constant)
   DECLARE_BASE_CAST(Supports_Condition)
   DECLARE_BASE_CAST(Selector)
-  DECLARE_BASE_CAST(Simple_Selector)
+  DECLARE_BASE_CAST(SimpleSelector)
+  DECLARE_BASE_CAST(SelectorComponent)
 
 }
 

data/ext/libsass/src/ast_helpers.hpp

@@ -0,0 +1,292 @@
+#ifndef SASS_AST_HELPERS_H
+#define SASS_AST_HELPERS_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+#include <algorithm>
+#include <functional>
+#include "util_string.hpp"
+
+namespace Sass {
+
+  // ###########################################################################
+  // ###########################################################################
+
+  // easier to search with name
+  const bool DELAYED = true;
+
+  // ToDo: should this really be hardcoded
+  // Note: most methods follow precision option
+  const double NUMBER_EPSILON = 1e-12;
+
+  // macro to test if numbers are equal within a small error margin
+  #define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON
+
+  // ###########################################################################
+  // We define various functions and functors here.
+  // Functions satisfy the BinaryPredicate requirement
+  // Functors are structs used for e.g. unordered_map
+  // ###########################################################################
+
+  // ###########################################################################
+  // Implement compare and hashing operations for raw pointers
+  // ###########################################################################
+
+  template <class T>
+  size_t PtrHashFn(const T* ptr) {
+    return std::hash<std::size_t>()((size_t)ptr);
+  }
+
+  struct PtrHash {
+    template <class T>
+    size_t operator() (const T* ptr) const {
+      return PtrHashFn(ptr);
+    }
+  };
+
+  template <class T>
+  bool PtrEqualityFn(const T* lhs, const T* rhs) {
+    return lhs == rhs; // compare raw pointers
+  }
+
+  struct PtrEquality {
+    template <class T>
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Implement compare and hashing operations for AST Nodes
+  // ###########################################################################
+
+  // TODO: get rid of funtions and use ObjEquality<T>
+
+  template <class T>
+  // Hash the raw pointer instead of object
+  size_t ObjPtrHashFn(const T& obj) {
+    return PtrHashFn(obj.ptr());
+  }
+
+  struct ObjPtrHash {
+    template <class T>
+    // Hash the raw pointer instead of object
+    size_t operator() (const T& obj) const {
+      return ObjPtrHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Hash the object and its content
+  size_t ObjHashFn(const T& obj) {
+    return obj ? obj->hash() : 0;
+  }
+
+  struct ObjHash {
+    template <class T>
+    // Hash the object and its content
+    size_t operator() (const T& obj) const {
+      return ObjHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Hash the object behind pointer
+  size_t PtrObjHashFn(const T* obj) {
+    return obj ? obj->hash() : 0;
+  }
+
+  struct PtrObjHash {
+    template <class T>
+    // Hash the object behind pointer
+    size_t operator() (const T* obj) const {
+      return PtrObjHashFn(obj);
+    }
+  };
+
+  template <class T>
+  // Compare raw pointers to the object
+  bool ObjPtrEqualityFn(const T& lhs, const T& rhs) {
+    return PtrEqualityFn(lhs.ptr(), rhs.ptr());
+  }
+
+  struct ObjPtrEquality {
+    template <class T>
+    // Compare raw pointers to the object
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjPtrEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects behind the pointers
+  bool PtrObjEqualityFn(const T* lhs, const T* rhs) {
+    if (lhs == nullptr) return rhs == nullptr;
+    else if (rhs == nullptr) return false;
+    else return *lhs == *rhs;
+  }
+
+  struct PtrObjEquality {
+    template <class T>
+    // Compare the objects behind the pointers
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrObjEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects and its contents
+  bool ObjEqualityFn(const T& lhs, const T& rhs) {
+    return PtrObjEqualityFn(lhs.ptr(), rhs.ptr());
+  }
+
+  struct ObjEquality {
+    template <class T>
+    // Compare the objects and its contents
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjEqualityFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Implement ordering operations for AST Nodes
+  // ###########################################################################
+
+  template <class T>
+  // Compare the objects behind pointers
+  bool PtrObjLessThanFn(const T* lhs, const T* rhs) {
+    if (lhs == nullptr) return rhs != nullptr;
+    else if (rhs == nullptr) return false;
+    else return *lhs < *rhs;
+  }
+
+  struct PtrObjLessThan {
+    template <class T>
+    // Compare the objects behind pointers
+    bool operator() (const T* lhs, const T* rhs) const {
+      return PtrObjLessThanFn<T>(lhs, rhs);
+    }
+  };
+
+  template <class T>
+  // Compare the objects and its content
+  bool ObjLessThanFn(const T& lhs, const T& rhs) {
+    return PtrObjLessThanFn(lhs.ptr(), rhs.ptr());
+  };
+
+  struct ObjLessThan {
+    template <class T>
+    // Compare the objects and its content
+    bool operator() (const T& lhs, const T& rhs) const {
+      return ObjLessThanFn<T>(lhs, rhs);
+    }
+  };
+
+  // ###########################################################################
+  // Some STL helper functions
+  // ###########################################################################
+
+  // Check if all elements are equal
+  template <class X, class Y,
+    typename XT = typename X::value_type,
+    typename YT = typename Y::value_type>
+  bool ListEquality(const X& lhs, const Y& rhs,
+    bool(*cmp)(const XT*, const YT*))
+  {
+    return lhs.size() == rhs.size() &&
+      std::equal(lhs.begin(), lhs.end(),
+        rhs.begin(), cmp);
+  }
+
+  // Return if Vector is empty
+  template <class T>
+  bool listIsEmpty(T* cnt) {
+    return cnt && cnt->empty();
+  }
+
+  // Erase items from vector that match predicate
+  template<class T, class UnaryPredicate>
+  void listEraseItemIf(T& vec, UnaryPredicate* predicate)
+  {
+    vec.erase(std::remove_if(vec.begin(), vec.end(), predicate), vec.end());
+  }
+
+  // Check that every item in `lhs` is also in `rhs`
+  // Note: this works by comparing the raw pointers
+  template <typename T>
+  bool listIsSubsetOrEqual(const T& lhs, const T& rhs) {
+    for (const auto& item : lhs) {
+      if (std::find(rhs.begin(), rhs.end(), item) == rhs.end())
+        return false;
+    }
+    return true;
+  }
+
+  // ##########################################################################
+  // Returns whether [name] is the name of a pseudo-element
+  // that can be written with pseudo-class syntax (CSS2 vs CSS3):
+  // `:before`, `:after`, `:first-line`, or `:first-letter`
+  // ##########################################################################
+  inline bool isFakePseudoElement(const std::string& name)
+  {
+    return Util::equalsLiteral("after", name)
+      || Util::equalsLiteral("before", name)
+      || Util::equalsLiteral("first-line", name)
+      || Util::equalsLiteral("first-letter", name);
+  }
+
+  // ##########################################################################
+  // Names of pseudo selectors that take selectors as arguments,
+  // and that are subselectors of their arguments.
+  // For example, `.foo` is a superselector of `:matches(.foo)`.
+  // ##########################################################################
+  inline bool isSubselectorPseudo(const std::string& norm)
+  {
+    return Util::equalsLiteral("any", norm)
+      || Util::equalsLiteral("matches", norm)
+      || Util::equalsLiteral("nth-child", norm)
+      || Util::equalsLiteral("nth-last-child", norm);
+  }
+  // EO isSubselectorPseudo
+
+  // ###########################################################################
+  // Pseudo-class selectors that take unadorned selectors as arguments.
+  // ###########################################################################
+  inline bool isSelectorPseudoClass(const std::string& test)
+  {
+    return Util::equalsLiteral("not", test)
+      || Util::equalsLiteral("matches", test)
+      || Util::equalsLiteral("current", test)
+      || Util::equalsLiteral("any", test)
+      || Util::equalsLiteral("has", test)
+      || Util::equalsLiteral("host", test)
+      || Util::equalsLiteral("host-context", test);
+  }
+  // EO isSelectorPseudoClass
+
+  // ###########################################################################
+  // Pseudo-element selectors that take unadorned selectors as arguments.
+  // ###########################################################################
+  inline bool isSelectorPseudoElement(const std::string& test)
+  {
+    return Util::equalsLiteral("slotted", test);
+  }
+  // EO isSelectorPseudoElement
+
+  // ###########################################################################
+  // Pseudo-element selectors that has binominals
+  // ###########################################################################
+  inline bool isSelectorPseudoBinominal(const std::string& test)
+  {
+    return Util::equalsLiteral("nth-child", test)
+      || Util::equalsLiteral("nth-last-child", test);
+  }
+  // isSelectorPseudoBinominal
+
+  // ###########################################################################
+  // ###########################################################################
+
+}
+
+#endif