sassc 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9080673dad2273d4097ecd900db41e63dea013a
-  data.tar.gz: 46faf54ba57c07110d44de98d32fed6e486fa840
+  metadata.gz: bc1ddb620763b2dad7308dd18a9c91c82192162d
+  data.tar.gz: c533165c997f081c2736e299e5de9da5bfe59d3b
 SHA512:
-  metadata.gz: 1186759b3cea8bd98914dce75264a0eab73ee53ec842719153bf6045c6673177106cf772ef7042f0c4ebc5c0f0079c77aeee7510938fb9a1363a015021537a7c
-  data.tar.gz: 59adf72cd185db6cd9d517b7677386b42c3ef8da593a13a8e5889c1a44b4aacb6cfd7499442764b588d2f4e463c08009a1aa22babc551a2a4f8638053d55f5f2
+  metadata.gz: addcd9ccee78f7b39e7c8931fbae374c19dee6601c14553255f3cc665c51985614c0b6a8abc223d3391b61f82170b296e64205693016fc71dd73c951f94b1a6b
+  data.tar.gz: 29f40e46fd1713286196044415f168b1e3b7c07169f54f9c564ef528d5d70357325bcdf27164018b94a88a974116e7dfe0be514b5099826b43070e83eb1a57e4

data/ext/libsass/ast.cpp

@@ -26,29 +26,29 @@ namespace Sass {
   }
 
   bool Complex_Selector::operator==(const Complex_Selector& rhs) const {
-  	// TODO: We have to access the tail directly using tail_ since ADD_PROPERTY doesn't provide a const version.
+    // TODO: We have to access the tail directly using tail_ since ADD_PROPERTY doesn't provide a const version.
 
-  	const Complex_Selector* pOne = this;
+    const Complex_Selector* pOne = this;
     const Complex_Selector* pTwo = &rhs;
 
     // Consume any empty references at the beginning of the Complex_Selector
     if (pOne->combinator() == Complex_Selector::ANCESTOR_OF && pOne->head()->is_empty_reference()) {
-    	pOne = pOne->tail_;
+      pOne = pOne->tail_;
     }
     if (pTwo->combinator() == Complex_Selector::ANCESTOR_OF && pTwo->head()->is_empty_reference()) {
-    	pTwo = pTwo->tail_;
+      pTwo = pTwo->tail_;
     }
 
     while (pOne && pTwo) {
-    	if (pOne->combinator() != pTwo->combinator()) {
-      	return false;
+      if (pOne->combinator() != pTwo->combinator()) {
+        return false;
       }
 
       if (*(pOne->head()) != *(pTwo->head())) {
-      	return false;
+        return false;
       }
 
-    	pOne = pOne->tail_;
+      pOne = pOne->tail_;
       pTwo = pTwo->tail_;
     }
 
@@ -68,10 +68,10 @@ namespace Sass {
 
   bool Simple_Selector::operator==(const Simple_Selector& rhs) const
   {
-  	// Compare the string representations for equality.
+    // Compare the string representations for equality.
 
-  	// Cast away const here. To_String should take a const object, but it doesn't.
-  	Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
+    // Cast away const here. To_String should take a const object, but it doesn't.
+    Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
     Simple_Selector* pRHS = const_cast<Simple_Selector*>(&rhs);
 
     To_String to_string;
@@ -79,10 +79,10 @@ namespace Sass {
   }
 
   bool Simple_Selector::operator<(const Simple_Selector& rhs) const {
-		// Use the string representation for ordering.
+    // Use the string representation for ordering.
 
-  	// Cast away const here. To_String should take a const object, but it doesn't.
-  	Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
+    // Cast away const here. To_String should take a const object, but it doesn't.
+    Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
     Simple_Selector* pRHS = const_cast<Simple_Selector*>(&rhs);
 
     To_String to_string;
@@ -217,32 +217,46 @@ namespace Sass {
     set<string> lpsuedoset, rpsuedoset;
     for (size_t i = 0, L = length(); i < L; ++i)
     {
-    	if ((*this)[i]->is_pseudo_element()) {
-      	string pseudo((*this)[i]->perform(&to_string));
+      if ((*this)[i]->is_pseudo_element()) {
+        string pseudo((*this)[i]->perform(&to_string));
         pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-      	lpsuedoset.insert(pseudo);
+        lpsuedoset.insert(pseudo);
       }
     }
     for (size_t i = 0, L = rhs->length(); i < L; ++i)
     {
-    	if ((*rhs)[i]->is_pseudo_element()) {
-      	string pseudo((*rhs)[i]->perform(&to_string));
+      if ((*rhs)[i]->is_pseudo_element()) {
+        string pseudo((*rhs)[i]->perform(&to_string));
         pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-	    	rpsuedoset.insert(pseudo);
+        rpsuedoset.insert(pseudo);
       }
     }
-  	if (lpsuedoset != rpsuedoset) {
+    if (lpsuedoset != rpsuedoset) {
       return false;
     }
 
-		// Check the Simple_Selectors
+    // Check the Simple_Selectors
 
     set<string> lset, rset;
 
     if (!lbase) // no lbase; just see if the left-hand qualifiers are a subset of the right-hand selector
     {
       for (size_t i = 0, L = length(); i < L; ++i)
-      { lset.insert((*this)[i]->perform(&to_string)); }
+      {
+        Selector* lhs = (*this)[i];
+        // very special case for wrapped matches selector
+        if (Wrapped_Selector* wrapped = dynamic_cast<Wrapped_Selector*>(lhs)) {
+          if (wrapped->name() == ":matches(" || wrapped->name() == ":-moz-any(") {
+            if (Selector_List* list = dynamic_cast<Selector_List*>(wrapped->selector())) {
+              if (Compound_Selector* comp = dynamic_cast<Compound_Selector*>(rhs)) {
+                if (list->is_superselector_of(comp)) return true;
+              }
+            }
+          }
+        }
+        // match from here on as strings
+        lset.insert(lhs->perform(&to_string));
+      }
       for (size_t i = 0, L = rhs->length(); i < L; ++i)
       { rset.insert((*rhs)[i]->perform(&to_string)); }
       return includes(rset.begin(), rset.end(), lset.begin(), lset.end());
@@ -274,33 +288,33 @@ namespace Sass {
     set<string> lpsuedoset, rpsuedoset;
     for (size_t i = 0, L = length(); i < L; ++i)
     {
-    	if ((*this)[i]->is_pseudo_element()) {
-      	string pseudo((*this)[i]->perform(&to_string));
+      if ((*this)[i]->is_pseudo_element()) {
+        string pseudo((*this)[i]->perform(&to_string));
         pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-      	lpsuedoset.insert(pseudo);
+        lpsuedoset.insert(pseudo);
       }
     }
     for (size_t i = 0, L = rhs.length(); i < L; ++i)
     {
-    	if (rhs[i]->is_pseudo_element()) {
-      	string pseudo(rhs[i]->perform(&to_string));
+      if (rhs[i]->is_pseudo_element()) {
+        string pseudo(rhs[i]->perform(&to_string));
         pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
-	    	rpsuedoset.insert(pseudo);
+        rpsuedoset.insert(pseudo);
       }
     }
-  	if (lpsuedoset != rpsuedoset) {
+    if (lpsuedoset != rpsuedoset) {
       return false;
     }
 
-		// Check the base
+    // Check the base
 
     const Simple_Selector* const lbase = base();
     const Simple_Selector* const rbase = rhs.base();
 
     if ((lbase && !rbase) ||
-    	(!lbase && rbase) ||
+      (!lbase && rbase) ||
       ((lbase && rbase) && (*lbase != *rbase))) {
-			return false;
+      return false;
     }
 
 
@@ -326,8 +340,6 @@ namespace Sass {
 
   bool Complex_Selector::is_superselector_of(Compound_Selector* rhs)
   {
-    if (length() != 1)
-    { return false; }
     return base()->is_superselector_of(rhs);
   }
 
@@ -352,6 +364,16 @@ namespace Sass {
     if (l_len == 1)
     { return lhs->head()->is_superselector_of(rhs->base()); }
 
+    // we have to look one tail deeper, since we cary the
+    // combinator around for it (which is important here)
+    if (rhs->tail() && lhs->tail() && combinator() != Complex_Selector::ANCESTOR_OF) {
+      Complex_Selector* lhs_tail = lhs->tail();
+      Complex_Selector* rhs_tail = rhs->tail();
+      if (lhs_tail->combinator() != rhs_tail->combinator()) return false;
+      if (!lhs_tail->head()->is_superselector_of(rhs_tail->head())) return false;
+    }
+
+
     bool found = false;
     Complex_Selector* marker = rhs;
     for (size_t i = 0, L = rhs->length(); i < L; ++i) {
@@ -458,7 +480,7 @@ namespace Sass {
     Complex_Selector* cpy = new (ctx.mem) Complex_Selector(*this);
 
     if (head()) {
-    	cpy->head(head()->clone(ctx));
+      cpy->head(head()->clone(ctx));
     }
 
     if (tail()) {
@@ -493,6 +515,50 @@ namespace Sass {
 #endif
   }
 
+  // it's a superselector if every selector of the right side
+  // list is a superselector of the given left side selector
+  bool Complex_Selector::is_superselector_of(Selector_List *sub)
+  {
+    // Check every rhs selector against left hand list
+    for(size_t i = 0, L = sub->length(); i < L; ++i) {
+      if (!is_superselector_of((*sub)[i])) return false;
+    }
+    return true;
+  }
+
+  // it's a superselector if every selector of the right side
+  // list is a superselector of the given left side selector
+  bool Selector_List::is_superselector_of(Selector_List *sub)
+  {
+    // Check every rhs selector against left hand list
+    for(size_t i = 0, L = sub->length(); i < L; ++i) {
+      if (!is_superselector_of((*sub)[i])) return false;
+    }
+    return true;
+  }
+
+  // it's a superselector if every selector on the right side
+  // is a superselector of any one of the left side selectors
+  bool Selector_List::is_superselector_of(Compound_Selector *sub)
+  {
+    // Check every lhs selector against right hand
+    for(size_t i = 0, L = length(); i < L; ++i) {
+      if ((*this)[i]->is_superselector_of(sub)) return true;
+    }
+    return false;
+  }
+
+  // it's a superselector if every selector on the right side
+  // is a superselector of any one of the left side selectors
+  bool Selector_List::is_superselector_of(Complex_Selector *sub)
+  {
+    // Check every lhs selector against right hand
+    for(size_t i = 0, L = length(); i < L; ++i) {
+      if ((*this)[i]->is_superselector_of(sub)) return true;
+    }
+    return false;
+  }
+
   /* not used anymore - remove?
   Selector_Placeholder* Selector_List::find_placeholder()
   {
@@ -663,7 +729,7 @@ namespace Sass {
       // skip already canceled out unit
       if (exponents[denom] >= 0) continue;
       // skip all units we don't know how to convert
-      if (string_to_unit(denom) == INCOMMENSURABLE) continue;
+      if (string_to_unit(denom) == UNKNOWN) continue;
       // now search for nominator
       while (nom_it != nom_end)
       {
@@ -672,7 +738,7 @@ namespace Sass {
         // skip already canceled out unit
         if (exponents[nom] <= 0) continue;
         // skip all units we don't know how to convert
-        if (string_to_unit(nom) == INCOMMENSURABLE) continue;
+        if (string_to_unit(nom) == UNKNOWN) continue;
         // we now have two convertable units
         // add factor for current conversion
         factor *= conversion_factor(nom, denom);
@@ -707,7 +773,10 @@ namespace Sass {
 
     // maybe convert to other unit
     // easier implemented on its own
-    convert(prefered);
+    try { convert(prefered); }
+    catch (incompatibleUnits& err)
+    { error(err.what(), pstate()); }
+    catch (...) { throw; }
 
   }
 
@@ -743,7 +812,7 @@ namespace Sass {
       // skip already canceled out unit
       if (exponents[denom] >= 0) continue;
       // skip all units we don't know how to convert
-      if (string_to_unit(denom) == INCOMMENSURABLE) continue;
+      if (string_to_unit(denom) == UNKNOWN) continue;
       // we now have two convertable units
       // add factor for current conversion
       factor *= conversion_factor(denom, prefered);
@@ -764,7 +833,7 @@ namespace Sass {
       // skip already canceled out unit
       if (exponents[nom] <= 0) continue;
       // skip all units we don't know how to convert
-      if (string_to_unit(nom) == INCOMMENSURABLE) continue;
+      if (string_to_unit(nom) == UNKNOWN) continue;
       // we now have two convertable units
       // add factor for current conversion
       factor *= conversion_factor(nom, prefered);
@@ -801,11 +870,11 @@ namespace Sass {
   {
     for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
       string u(numerator_units_[i]);
-      if (string_to_unit(u) != INCOMMENSURABLE) return u;
+      if (string_to_unit(u) != UNKNOWN) return u;
     }
     for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
       string u(denominator_units_[i]);
-      if (string_to_unit(u) != INCOMMENSURABLE) return u;
+      if (string_to_unit(u) != UNKNOWN) return u;
     }
     return string();
   }
@@ -853,6 +922,18 @@ namespace Sass {
     return operator==(&rhs);
   }
 
+  size_t List::size() const {
+    if (!is_arglist_) return length();
+    // arglist expects a list of arguments
+    // so we need to break before keywords
+    for (size_t i = 0, L = length(); i < L; ++i) {
+      if (Argument* arg = dynamic_cast<Argument*>((*this)[i])) {
+        if (!arg->name().empty()) return i;
+      }
+    }
+    return length();
+  }
+
   Expression* Hashed::at(Expression* k) const
   {
     if (elements_.count(k))

data/ext/libsass/ast.hpp

@@ -757,6 +757,7 @@ namespace Sass {
     bool is_invisible() { return !length(); }
     Expression* value_at_index(size_t i);
 
+    virtual size_t size() const;
     virtual bool operator==(Expression& rhs) const;
     virtual bool operator==(Expression* rhs) const;
 
@@ -1359,21 +1360,22 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark);
+    ADD_PROPERTY(bool, can_compress_whitespace);
     ADD_PROPERTY(string, value);
   protected:
     size_t hash_;
   public:
     String_Constant(ParserState pstate, string val)
-    : String(pstate), quote_mark_(0), value_(read_css_string(val)), hash_(0)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(val)), hash_(0)
     { }
     String_Constant(ParserState pstate, const char* beg)
-    : String(pstate), quote_mark_(0), value_(read_css_string(string(beg))), hash_(0)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(string(beg))), hash_(0)
     { }
     String_Constant(ParserState pstate, const char* beg, const char* end)
-    : String(pstate), quote_mark_(0), value_(read_css_string(string(beg, end-beg))), hash_(0)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(string(beg, end-beg))), hash_(0)
     { }
     String_Constant(ParserState pstate, const Token& tok)
-    : String(pstate), quote_mark_(0), value_(read_css_string(string(tok.begin, tok.end))), hash_(0)
+    : String(pstate), quote_mark_(0), can_compress_whitespace_(false), value_(read_css_string(string(tok.begin, tok.end))), hash_(0)
     { }
     string type() { return "string"; }
     static string type_name() { return "string"; }
@@ -1941,7 +1943,9 @@ namespace Sass {
         return (*this)[0];
       return 0;
     }
-    bool is_superselector_of(Compound_Selector* rhs);
+    bool is_superselector_of(Compound_Selector* sub);
+    // bool is_superselector_of(Complex_Selector* sub);
+    // bool is_superselector_of(Selector_List* sub);
     virtual unsigned long specificity()
     {
       int sum = 0;
@@ -1998,8 +2002,9 @@ namespace Sass {
     Complex_Selector* context(Context&);
     Complex_Selector* innermost();
     size_t length();
-    bool is_superselector_of(Compound_Selector*);
-    bool is_superselector_of(Complex_Selector*);
+    bool is_superselector_of(Compound_Selector* sub);
+    bool is_superselector_of(Complex_Selector* sub);
+    bool is_superselector_of(Selector_List* sub);
     // virtual Selector_Placeholder* find_placeholder();
     Combinator clear_innermost();
     void set_innermost(Complex_Selector*, Combinator);
@@ -2084,6 +2089,9 @@ namespace Sass {
     : Selector(pstate), Vectorized<Complex_Selector*>(s), wspace_(0)
     { }
     // virtual Selector_Placeholder* find_placeholder();
+    bool is_superselector_of(Compound_Selector* sub);
+    bool is_superselector_of(Complex_Selector* sub);
+    bool is_superselector_of(Selector_List* sub);
     virtual unsigned long specificity()
     {
       unsigned long sum = 0;

data/ext/libsass/bind.cpp

@@ -47,14 +47,40 @@ namespace Sass {
 
       // If the current parameter is the rest parameter, process and break the loop
       if (p->is_rest_parameter()) {
+        // The next argument by coincidence provides a rest argument
         if (a->is_rest_argument()) {
-          // rest param and rest arg -- just add one to the other
-          if (env->has_local(p->name())) {
-            *static_cast<List*>(env->local_frame()[p->name()])
-            += static_cast<List*>(a->value());
+          // We should always get a list for rest arguments
+          if (List* rest = dynamic_cast<List*>(a->value())) {
+            // arg contains a list
+            List* args = rest;
+            // make sure it's an arglist
+            if (rest->is_arglist()) {
+              // can pass it through as it was
+              env->local_frame()[p->name()] = args;
+            }
+            // create a new list and wrap each item as an argument
+            // otherwise we will not be able to fetch it again
+            else {
+              // create a new list object for wrapped items
+              List* arglist = new (ctx.mem) List(p->pstate(),
+                                                 0,
+                                                 rest->separator(),
+                                                 true);
+              // wrap each item from list as an argument
+              for (Expression* item : rest->elements()) {
+                (*arglist) << new (ctx.mem) Argument(item->pstate(),
+                                                     item,
+                                                     "",
+                                                     false,
+                                                     false);
+              }
+              // assign new arglist to environment
+              env->local_frame()[p->name()] = arglist;
+            }
           }
+          // invalid state
           else {
-            env->local_frame()[p->name()] = a->value();
+            throw runtime_error("invalid state");
           }
         } else if (a->is_keyword_argument()) {
 
@@ -67,27 +93,43 @@ namespace Sass {
             (*arglist) << new (ctx.mem) Argument(key->pstate(),
                                                  argmap->at(key),
                                                  name,
+                                                 false,
                                                  false);
           }
 
         } else {
 
-          // copy all remaining arguments into the rest parameter, preserving names
+          // create a new list object for wrapped items
           List* arglist = new (ctx.mem) List(p->pstate(),
                                              0,
                                              List::COMMA,
                                              true);
-          env->local_frame()[p->name()] = arglist;
+          // consume the next args
           while (ia < LA) {
-            a = (*as)[ia];
+            // get and post inc
+            a = (*as)[ia++];
+            // wrap current argument into new object
             (*arglist) << new (ctx.mem) Argument(a->pstate(),
                                                  a->value(),
                                                  a->name(),
+                                                 false,
                                                  false);
-            ++ia;
+            // check if we have rest argument
+            if (a->is_rest_argument()) {
+              // preserve the list separator from rest args
+              if (List* rest = dynamic_cast<List*>(a->value())) {
+                arglist->separator(rest->separator());
+              }
+              // no more arguments
+              break;
+            }
           }
+          // assign new arglist to environment
+          env->local_frame()[p->name()] = arglist;
         }
+        // consumed parameter
         ++ip;
+        // no more paramaters
         break;
       }
 
@@ -104,7 +146,11 @@ namespace Sass {
           a = static_cast<Argument*>((*arglist)[0]);
         } else {
           Expression* a_to_convert = (*arglist)[0];
-          a = new (ctx.mem) Argument(a_to_convert->pstate(), a_to_convert, "", false);
+          a = new (ctx.mem) Argument(a_to_convert->pstate(),
+                                     a_to_convert,
+                                     "",
+                                     false,
+                                     false);
         }
         arglist->elements().erase(arglist->elements().begin());
         if (!arglist->length() || (!arglist->is_arglist() && ip + 1 == LP)) {
@@ -162,6 +208,7 @@ namespace Sass {
         env->local_frame()[a->name()] = a->value();
       }
     }
+    // EO while ia
 
     // If we make it here, we're out of args but may have leftover params.
     // That's only okay if they have default values, or were already bound by