sassc 1.9.0 → 1.10.0

data/ext/libsass/src/cssize.hpp

@@ -16,6 +16,7 @@ namespace Sass {
     Context&                 ctx;
     std::vector<Block*>      block_stack;
     std::vector<Statement*>  p_stack;
+    std::vector<Selector_List*> s_stack;
     Backtrace*               backtrace;
 
     Statement* fallback_impl(AST_Node* n);
@@ -24,6 +25,8 @@ namespace Sass {
     Cssize(Context&, Backtrace*);
     ~Cssize() { }
 
+    Selector_List* selector();
+
     Statement* operator()(Block*);
     Statement* operator()(Ruleset*);
     // Statement* operator()(Propset*);
@@ -31,7 +34,7 @@ namespace Sass {
     Statement* operator()(Media_Block*);
     Statement* operator()(Supports_Block*);
     Statement* operator()(At_Root_Block*);
-    Statement* operator()(At_Rule*);
+    Statement* operator()(Directive*);
     Statement* operator()(Keyframe_Rule*);
     // Statement* operator()(Declaration*);
     // Statement* operator()(Assignment*);
@@ -53,7 +56,7 @@ namespace Sass {
 
     Statement* parent();
     std::vector<std::pair<bool, Block*>> slice_by_bubble(Statement*);
-    Statement* bubble(At_Rule*);
+    Statement* bubble(Directive*);
     Statement* bubble(At_Root_Block*);
     Statement* bubble(Media_Block*);
     Statement* bubble(Supports_Block*);

data/ext/libsass/src/debugger.hpp

@@ -352,6 +352,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Content* block = dynamic_cast<Content*>(node);
     std::cerr << ind << "Content " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
+    std::cerr << " [@media:" << block->media_block() << "]";
     std::cerr << " " << block->tabs() << std::endl;
   } else if (dynamic_cast<Import_Stub*>(node)) {
     Import_Stub* block = dynamic_cast<Import_Stub*>(node);
@@ -387,9 +388,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     std::cerr << " " << has_block->tabs() << std::endl;
     if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
     if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
-  } else if (dynamic_cast<At_Rule*>(node)) {
-    At_Rule* block = dynamic_cast<At_Rule*>(node);
-    std::cerr << ind << "At_Rule " << block;
+  } else if (dynamic_cast<Directive*>(node)) {
+    Directive* block = dynamic_cast<Directive*>(node);
+    std::cerr << ind << "Directive " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
     debug_ast(block->selector(), ind + "~", env);
@@ -556,6 +557,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
       (expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
       " [delayed: " << expression->is_delayed() << "] " <<
       " [interpolant: " << expression->is_interpolant() << "] " <<
+      " [listized: " << expression->from_selector() << "] " <<
       " [arglist: " << expression->is_arglist() << "] " <<
       " [hash: " << expression->hash() << "] " <<
       std::endl;
@@ -564,6 +566,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Content* expression = dynamic_cast<Content*>(node);
     std::cerr << ind << "Content " << expression;
     std::cerr << " (" << pstate_source_position(node) << ")";
+    std::cerr << " [@media:" << expression->media_block() << "]";
     std::cerr << " [Statement]" << std::endl;
   } else if (dynamic_cast<Boolean*>(node)) {
     Boolean* expression = dynamic_cast<Boolean*>(node);

data/ext/libsass/src/emitter.cpp

@@ -204,7 +204,7 @@ namespace Sass {
   void Emitter::append_optional_space()
   {
     if ((output_style() != COMPRESSED) && buffer().size()) {
-      char lst = buffer().at(buffer().length() - 1);
+      unsigned char lst = buffer().at(buffer().length() - 1);
       if (!isspace(lst) || scheduled_delimiter) {
         append_mandatory_space();
       }

data/ext/libsass/src/environment.cpp

@@ -180,7 +180,7 @@ namespace Sass {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
         std::cerr << prefix << std::string(indent, ' ') << i->first << " "  << i->second;
         if (Value* val = dynamic_cast<Value*>(i->second))
-        { std::cerr << " : " << val->to_string(true, 5); }
+        { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;
       }
     }

data/ext/libsass/src/eval.cpp

@@ -458,6 +458,7 @@ namespace Sass {
       *ll << (*l)[i]->perform(this);
     }
     ll->is_interpolant(l->is_interpolant());
+    ll->from_selector(l->from_selector());
     ll->is_expanded(true);
     return ll;
   }
@@ -834,15 +835,31 @@ namespace Sass {
     }
     std::string name(Util::normalize_underscores(c->name()));
     std::string full_name(name + "[f]");
-    Arguments* args = c->arguments();
-    if (full_name != "if[f]") {
-      args = static_cast<Arguments*>(args->perform(this));
+    Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, *c->arguments());
+
+    // handle call here if valid arg
+    // otherwise we eval arguments to early
+    if (name == "call" && args->length() > 0) {
+      Expression* redirect = args->at(0)->perform(this);
+      args->erase(args->begin());
+      Function_Call* lit = SASS_MEMORY_NEW(ctx.mem, Function_Call,
+                                           c->pstate(),
+                                           unquote(redirect->to_string()),
+                                           args);
+      return operator()(lit);
     }
 
     Env* env = environment();
     if (!env->has(full_name)) {
       if (!env->has("*[f]")) {
         // just pass it through as a literal
+        for (Argument* arg : *args) {
+          if (Binary_Expression* b = dynamic_cast<Binary_Expression*>(arg->value())) {
+            b->reset_whitespace();
+            arg->is_delayed(b->can_delay()); // delay
+          }
+        }
+        args = static_cast<Arguments*>(args->perform(this));
         Function_Call* lit = SASS_MEMORY_NEW(ctx.mem, Function_Call,
                                              c->pstate(),
                                              c->name(),
@@ -861,6 +878,10 @@ namespace Sass {
       }
     }
 
+    if (full_name != "if[f]") {
+      args = static_cast<Arguments*>(args->perform(this));
+    }
+
     Definition* def = static_cast<Definition*>((*env)[full_name]);
 
     if (def->is_overload_stub()) {
@@ -1087,7 +1108,7 @@ namespace Sass {
   void Eval::interpolation(Context& ctx, std::string& res, Expression* ex, bool into_quotes, bool was_itpl) {
 
     bool needs_closing_brace = false;
-//debug_ast(ex);
+
     if (Arguments* args = dynamic_cast<Arguments*>(ex)) {
       List* ll = SASS_MEMORY_NEW(ctx.mem, List, args->pstate(), 0, SASS_COMMA);
       for(auto arg : *args) {
@@ -1165,8 +1186,10 @@ namespace Sass {
       if (!dynamic_cast<String_Quoted*>((*s)[0]) && !dynamic_cast<String_Quoted*>((*s)[L - 1])) {
       if (String_Constant* l = dynamic_cast<String_Constant*>((*s)[0])) {
         if (String_Constant* r = dynamic_cast<String_Constant*>((*s)[L - 1])) {
-          if (l->value()[0] == '"' && r->value()[r->value().size() - 1] == '"') into_quotes = true;
-          if (l->value()[0] == '\'' && r->value()[r->value().size() - 1] == '\'') into_quotes = true;
+          if (r->value().size() > 0) {
+            if (l->value()[0] == '"' && r->value()[r->value().size() - 1] == '"') into_quotes = true;
+            if (l->value()[0] == '\'' && r->value()[r->value().size() - 1] == '\'') into_quotes = true;
+          }
         }
       }
       }
@@ -1176,7 +1199,6 @@ namespace Sass {
     std::string res("");
     for (size_t i = 0; i < L; ++i) {
       bool is_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
-      (*s)[i]->perform(this);
       if (was_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
       else if (i > 0 && is_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
       Expression* ex = (*s)[i]->is_delayed() ? (*s)[i] : (*s)[i]->perform(this);
@@ -1260,17 +1282,16 @@ namespace Sass {
     return cc;
   }
 
-  Expression* Eval::operator()(At_Root_Expression* e)
+  Expression* Eval::operator()(At_Root_Query* e)
   {
     Expression* feature = e->feature();
     feature = (feature ? feature->perform(this) : 0);
     Expression* value = e->value();
     value = (value ? value->perform(this) : 0);
-    Expression* ee = SASS_MEMORY_NEW(ctx.mem, At_Root_Expression,
+    Expression* ee = SASS_MEMORY_NEW(ctx.mem, At_Root_Query,
                                      e->pstate(),
                                      static_cast<String*>(feature),
-                                     value,
-                                     e->is_interpolated());
+                                     value);
     return ee;
   }
 
@@ -1322,7 +1343,8 @@ namespace Sass {
   Expression* Eval::operator()(Argument* a)
   {
     Expression* val = a->value();
-    val->is_delayed(false);
+    // delay missin function arguments?
+    val->is_delayed(a->is_delayed());
     val = val->perform(this);
     val->is_delayed(false);
 
@@ -1355,6 +1377,7 @@ namespace Sass {
   Expression* Eval::operator()(Arguments* a)
   {
     Arguments* aa = SASS_MEMORY_NEW(ctx.mem, Arguments, a->pstate());
+    if (a->length() == 0) return aa;
     for (size_t i = 0, L = a->length(); i < L; ++i) {
       Argument* arg = static_cast<Argument*>((*a)[i]->perform(this));
       if (!(arg->is_rest_argument() || arg->is_keyword_argument())) {
@@ -1660,7 +1683,9 @@ namespace Sass {
   {
     std::vector<Selector_List*> rv;
     Selector_List* sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, s->pstate());
+    sl->is_optional(s->is_optional());
     sl->media_block(s->media_block());
+    sl->is_optional(s->is_optional());
     for (size_t i = 0, iL = s->length(); i < iL; ++i) {
       rv.push_back(operator()((*s)[i]));
     }
@@ -1707,9 +1732,12 @@ namespace Sass {
   {
     // the parser will look for a brace to end the selector
     std::string result_str(s->contents()->perform(this)->to_string(ctx.c_options));
-    result_str = unquote(Util::rtrim(result_str)) + "{";
+    result_str = unquote(Util::rtrim(result_str)) + "\n{";
     Parser p = Parser::from_c_str(result_str.c_str(), ctx, s->pstate());
-    return operator()(p.parse_selector_list(exp.block_stack.back()->is_root()));
+    p.last_media_block = s->media_block();
+    Selector_List* sl = p.parse_selector_list(exp.block_stack.back()->is_root());
+    if (s->has_parent_ref()) sl->remove_parent_selectors();
+    return operator()(sl);
   }
 
   Expression* Eval::operator()(Parent_Selector* p)

data/ext/libsass/src/eval.hpp

@@ -57,7 +57,7 @@ namespace Sass {
     // Expression* operator()(Selector_List*);
     Expression* operator()(Media_Query*);
     Expression* operator()(Media_Query_Expression*);
-    Expression* operator()(At_Root_Expression*);
+    Expression* operator()(At_Root_Query*);
     Expression* operator()(Supports_Operator*);
     Expression* operator()(Supports_Negation*);
     Expression* operator()(Supports_Declaration*);

data/ext/libsass/src/expand.cpp

@@ -19,6 +19,7 @@ namespace Sass {
     call_stack(std::vector<AST_Node*>()),
     property_stack(std::vector<String*>()),
     selector_stack(std::vector<Selector_List*>()),
+    media_block_stack(std::vector<Media_Block*>()),
     backtrace_stack(std::vector<Backtrace*>()),
     in_keyframes(false)
   {
@@ -29,6 +30,7 @@ namespace Sass {
     // import_stack.push_back(0);
     property_stack.push_back(0);
     selector_stack.push_back(0);
+    media_block_stack.push_back(0);
     backtrace_stack.push_back(0);
     backtrace_stack.push_back(bt);
   }
@@ -134,6 +136,7 @@ namespace Sass {
       env = new Env(environment());
       env_stack.push_back(env);
     }
+    sel->set_media_block(media_block_stack.back());
     Block* blk = r->block()->perform(this)->block();
     Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
                                   r->pstate(),
@@ -144,6 +147,7 @@ namespace Sass {
       env_stack.pop_back();
       delete env;
     }
+    rr->is_root(r->is_root());
     rr->tabs(r->tabs());
 
     return rr;
@@ -195,9 +199,10 @@ namespace Sass {
 
   Statement* Expand::operator()(Media_Block* m)
   {
+    media_block_stack.push_back(m);
     Expression* mq = m->media_queries()->perform(&eval);
     std::string str_mq(mq->to_string(ctx.c_options));
-    char* str = sass_strdup(str_mq.c_str());
+    char* str = sass_copy_c_string(str_mq.c_str());
     ctx.strings.push_back(str);
     Parser p(Parser::from_c_str(str, ctx, mq->pstate()));
     mq = p.parse_media_queries();
@@ -206,6 +211,7 @@ namespace Sass {
                                       static_cast<List*>(mq->perform(&eval)),
                                       m->block()->perform(this)->block(),
                                       0);
+    media_block_stack.pop_back();
     mm->tabs(m->tabs());
     return mm;
   }
@@ -216,17 +222,17 @@ namespace Sass {
     // if (ab) ab->is_root(true);
     Expression* ae = a->expression();
     if (ae) ae = ae->perform(&eval);
-    else ae = SASS_MEMORY_NEW(ctx.mem, At_Root_Expression, a->pstate());
+    else ae = SASS_MEMORY_NEW(ctx.mem, At_Root_Query, a->pstate());
     Block* bb = ab ? ab->perform(this)->block() : 0;
     At_Root_Block* aa = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
                                         a->pstate(),
                                         bb,
-                                        static_cast<At_Root_Expression*>(ae));
+                                        static_cast<At_Root_Query*>(ae));
     // aa->block()->is_root(true);
     return aa;
   }
 
-  Statement* Expand::operator()(At_Rule* a)
+  Statement* Expand::operator()(Directive* a)
   {
     LOCAL_FLAG(in_keyframes, a->is_keyframes());
     Block* ab = a->block();
@@ -237,7 +243,7 @@ namespace Sass {
     if (as) as = dynamic_cast<Selector*>(as->perform(&eval));
     selector_stack.pop_back();
     Block* bb = ab ? ab->perform(this)->block() : 0;
-    At_Rule* aa = SASS_MEMORY_NEW(ctx.mem, At_Rule,
+    Directive* aa = SASS_MEMORY_NEW(ctx.mem, Directive,
                                   a->pstate(),
                                   a->keyword(),
                                   as,
@@ -593,7 +599,7 @@ namespace Sass {
         error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
       Compound_Selector* placeholder = c->head();
-      placeholder->is_optional(s->is_optional());
+      if (contextualized->is_optional()) placeholder->is_optional(true);
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
         Complex_Selector* sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
@@ -621,8 +627,18 @@ namespace Sass {
   Statement* Expand::operator()(Extension* e)
   {
     if (Selector_List* extender = dynamic_cast<Selector_List*>(selector())) {
-      selector_stack.push_back(0);
       Selector* s = e->selector();
+      if (Selector_Schema* schema = dynamic_cast<Selector_Schema*>(s)) {
+        if (schema->has_parent_ref()) s = eval(schema);
+      }
+      if (Selector_List* sl = dynamic_cast<Selector_List*>(s)) {
+        for (Complex_Selector* cs : *sl) {
+          if (cs != NULL && cs->head() != NULL) {
+            cs->head()->media_block(media_block_stack.back());
+          }
+        }
+      }
+      selector_stack.push_back(0);
       expand_selector_list(s, extender);
       selector_stack.pop_back();
     }
@@ -637,7 +653,7 @@ namespace Sass {
                         (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd;
 
     if (d->type() == Definition::FUNCTION && (
-      d->name() == "calc"       ||
+      Prelexer::calc_fn_call(d->name().c_str()) ||
       d->name() == "element"    ||
       d->name() == "expression" ||
       d->name() == "url"

data/ext/libsass/src/expand.hpp

@@ -33,6 +33,7 @@ namespace Sass {
     std::vector<AST_Node*> call_stack;
     std::vector<String*>   property_stack;
     std::vector<Selector_List*> selector_stack;
+    std::vector<Media_Block*> media_block_stack;
     std::vector<Backtrace*>backtrace_stack;
     bool              in_keyframes;
 
@@ -51,7 +52,7 @@ namespace Sass {
     Statement* operator()(Media_Block*);
     Statement* operator()(Supports_Block*);
     Statement* operator()(At_Root_Block*);
-    Statement* operator()(At_Rule*);
+    Statement* operator()(Directive*);
     Statement* operator()(Declaration*);
     Statement* operator()(Assignment*);
     Statement* operator()(Import*);

data/ext/libsass/src/extend.cpp

@@ -6,6 +6,7 @@
 #include "parser.hpp"
 #include "node.hpp"
 #include "sass_util.hpp"
+#include "remove_placeholders.hpp"
 #include "debug.hpp"
 #include <iostream>
 #include <deque>
@@ -1463,6 +1464,7 @@ namespace Sass {
       Node current = afters.collection()->front().clone(ctx);
       afters.collection()->pop_front();
       DEBUG_PRINTLN(WEAVE, "CURRENT: " << current)
+      if (current.collection()->size() == 0) continue;
 
       Node last_current = Node::createCollection();
       last_current.collection()->push_back(current.collection()->back());
@@ -1737,14 +1739,14 @@ namespace Sass {
         SubsetMapEntries entries = subset_map.get_v(pHead->to_str_vec());
         for (ExtensionPair ext : entries) {
           // check if both selectors have the same media block parent
-          if (ext.first->media_block() == pComplexSelector->media_block()) continue;
+          // if (ext.first->media_block() == pComplexSelector->media_block()) continue;
           if (ext.second->media_block() == 0) continue;
-          if (pComplexSelector->media_block() &&
+          if (pHead->media_block() &&
               ext.second->media_block()->media_queries() &&
-              pComplexSelector->media_block()->media_queries()
+              pHead->media_block()->media_queries()
           ) {
             std::string query_left(ext.second->media_block()->media_queries()->to_string(ctx.c_options));
-            std::string query_right(pComplexSelector->media_block()->media_queries()->to_string(ctx.c_options));
+            std::string query_right(pHead->media_block()->media_queries()->to_string(ctx.c_options));
             if (query_left == query_right) continue;
           }
 
@@ -1943,19 +1945,57 @@ namespace Sass {
       }
     }
 
-    for (Complex_Selector* cs : *pNewSelectors) {
-      while (cs) {
-        if (cs->head()) {
-        for (Simple_Selector* ss : *cs->head()) {
-          if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
-            if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
-              bool extended = false;
-              ws->selector(extendSelectorList(sl, ctx, subset_map, false, extended));
+    Remove_Placeholders remove_placeholders(ctx);
+    // it seems that we have to remove the place holders early here
+    // normally we do this as the very last step (compare to ruby sass)
+    pNewSelectors = remove_placeholders.remove_placeholders(pNewSelectors);
+
+    // unwrap all wrapped selectors with inner lists
+    for (Complex_Selector* cur : *pNewSelectors) {
+      // process tails
+      while (cur) {
+        // process header
+        if (cur->head()) {
+          // create a copy since we add multiple items if stuff get unwrapped
+          Compound_Selector* cpy_head = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, cur->pstate());
+          for (Simple_Selector* hs : *cur->head()) {
+            if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(hs)) {
+              if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
+                // special case for ruby ass
+                if (sl->empty()) {
+                  // this seems inconsistent but it is how ruby sass seems to remove parentheses
+                  *cpy_head << SASS_MEMORY_NEW(ctx.mem, Type_Selector, hs->pstate(), ws->name());
+                }
+                // has wrapped selectors
+                else {
+                  // extend the inner list of wrapped selector
+                  Selector_List* ext_sl = extendSelectorList(sl, ctx, subset_map);
+                  for (size_t i = 0; i < ext_sl->length(); i += 1) {
+                    if (Complex_Selector* ext_cs = ext_sl->at(i)) {
+                      // create clones for wrapped selector and the inner list
+                      Wrapped_Selector* cpy_ws = SASS_MEMORY_NEW(ctx.mem, Wrapped_Selector, *ws);
+                      Selector_List* cpy_ws_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
+                      // remove parent selectors from inner selector
+                      if (ext_cs->first()) *cpy_ws_sl << ext_cs->first();
+                      // assign list to clone
+                      cpy_ws->selector(cpy_ws_sl);
+                      // append the clone
+                      *cpy_head << cpy_ws;
+                    }
+                  }
+                }
+              } else {
+                *cpy_head << hs;
+              }
+            } else {
+              *cpy_head << hs;
             }
           }
+          // replace header
+          cur->head(cpy_head);
         }
-        }
-        cs = cs->tail();
+        // process tail
+        cur = cur->tail();
       }
     }
     return pNewSelectors;
@@ -2068,7 +2108,7 @@ namespace Sass {
     pMediaBlock->block()->perform(this);
   }
 
-  void Extend::operator()(At_Rule* a)
+  void Extend::operator()(Directive* a)
   {
     // Selector_List* ls = dynamic_cast<Selector_List*>(a->selector());
     // selector_stack.push_back(ls);