sassc 1.11.4 → 1.12.0

data/ext/libsass/src/functions.hpp

@@ -8,13 +8,12 @@
 #include "sass/functions.h"
 
 #define BUILT_IN(name) Expression_Ptr \
-name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtrace* backtrace, std::vector<Selector_List_Obj> selector_stack)
+name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtraces traces, std::vector<Selector_List_Obj> selector_stack)
 
 namespace Sass {
   struct Backtrace;
-  typedef Environment<AST_Node_Obj> Env;
   typedef const char* Signature;
-  typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<Selector_List_Obj>);
+  typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtraces, std::vector<Selector_List_Obj>);
 
   Definition_Ptr make_native_function(Signature, Native_Function, Context& ctx);
   Definition_Ptr make_c_function(Sass_Function_Entry c_func, Context& ctx);
@@ -89,7 +88,6 @@ namespace Sass {
     extern Signature call_sig;
     extern Signature not_sig;
     extern Signature if_sig;
-    extern Signature image_url_sig;
     extern Signature map_get_sig;
     extern Signature map_merge_sig;
     extern Signature map_remove_sig;
@@ -107,6 +105,9 @@ namespace Sass {
     extern Signature is_superselector_sig;
     extern Signature simple_selectors_sig;
     extern Signature selector_parse_sig;
+    extern Signature is_bracketed_sig;
+    extern Signature content_exists_sig;
+    extern Signature get_function_sig;
 
     BUILT_IN(rgb);
     BUILT_IN(rgba_4);
@@ -171,7 +172,6 @@ namespace Sass {
     BUILT_IN(call);
     BUILT_IN(sass_not);
     BUILT_IN(sass_if);
-    BUILT_IN(image_url);
     BUILT_IN(map_get);
     BUILT_IN(map_merge);
     BUILT_IN(map_remove);
@@ -189,6 +189,9 @@ namespace Sass {
     BUILT_IN(is_superselector);
     BUILT_IN(simple_selectors);
     BUILT_IN(selector_parse);
+    BUILT_IN(is_bracketed);
+    BUILT_IN(content_exists);
+    BUILT_IN(get_function);
   }
 }
 

data/ext/libsass/src/inspect.cpp

@@ -15,7 +15,7 @@
 
 namespace Sass {
 
-  Inspect::Inspect(Emitter emi)
+  Inspect::Inspect(const Emitter& emi)
   : Emitter(emi)
   { }
   Inspect::~Inspect() { }
@@ -42,7 +42,9 @@ namespace Sass {
   void Inspect::operator()(Ruleset_Ptr ruleset)
   {
     if (ruleset->selector()) {
+      opt.in_selector = true;
       ruleset->selector()->perform(this);
+      opt.in_selector = false;
     }
     if (ruleset->block()) {
       ruleset->block()->perform(this);
@@ -90,7 +92,7 @@ namespace Sass {
     append_token("@at-root ", at_root_block);
     append_mandatory_space();
     if(at_root_block->expression()) at_root_block->expression()->perform(this);
-    at_root_block->block()->perform(this);
+    if(at_root_block->block()) at_root_block->block()->perform(this);
   }
 
   void Inspect::operator()(Directive_Ptr at_rule)
@@ -121,6 +123,8 @@ namespace Sass {
     if (dec->value()->concrete_type() == Expression::NULL_VAL) return;
     bool was_decl = in_declaration;
     in_declaration = true;
+    LOCAL_FLAG(in_custom_property, dec->is_custom_property());
+
     if (output_style() == NESTED)
       indentation += dec->tabs();
     append_indentation();
@@ -166,7 +170,7 @@ namespace Sass {
 
       import->urls().front()->perform(this);
       if (import->urls().size() == 1) {
-        if (&import->import_queries()) {
+        if (import->import_queries()) {
           append_mandatory_space();
           import->import_queries()->perform(this);
         }
@@ -179,7 +183,7 @@ namespace Sass {
 
         import->urls()[i]->perform(this);
         if (import->urls().size() - 1 == i) {
-          if (&import->import_queries()) {
+          if (import->import_queries()) {
             append_mandatory_space();
             import->import_queries()->perform(this);
           }
@@ -354,16 +358,27 @@ namespace Sass {
       if (items_output) append_comma_separator();
       key->perform(this);
       append_colon_separator();
+      LOCAL_FLAG(in_space_array, true);
+      LOCAL_FLAG(in_comma_array, true);
       map->at(key)->perform(this);
       items_output = true;
     }
     append_string(")");
   }
 
+  std::string Inspect::lbracket(List_Ptr list) {
+    return list->is_bracketed() ? "[" : "(";
+  }
+
+  std::string Inspect::rbracket(List_Ptr list) {
+    return list->is_bracketed() ? "]" : ")";
+  }
+
   void Inspect::operator()(List_Ptr list)
   {
-    if (output_style() == TO_SASS && list->empty()) {
-      append_string("()");
+    if (list->empty() && (output_style() == TO_SASS || list->is_bracketed())) {
+      append_string(lbracket(list));
+      append_string(rbracket(list));
       return;
     }
     std::string sep(list->separator() == SASS_SPACE ? " " : ",");
@@ -374,19 +389,24 @@ namespace Sass {
 
     bool was_space_array = in_space_array;
     bool was_comma_array = in_comma_array;
+    // if the list is bracketed, always include the left bracket
+    if (list->is_bracketed()) {
+      append_string(lbracket(list));
+    }
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS &&
+    else if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
-        !SASS_MEMORY_CAST(List, list->at(0)) &&
-        !SASS_MEMORY_CAST(Selector_List, list->at(0))) {
-      append_string("(");
+        !Cast<List>(list->at(0)) &&
+        !Cast<Selector_List>(list->at(0))
+    ) {
+      append_string(lbracket(list));
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string("(");
+      append_string(lbracket(list));
     }
 
     if (list->separator() == SASS_SPACE) in_space_array = true;
@@ -399,7 +419,7 @@ namespace Sass {
       if (output_style() != TO_SASS) {
         if (list_item->is_invisible()) {
           // this fixes an issue with "" in a list
-          if (!SASS_MEMORY_CAST(String_Constant, list_item)) {
+          if (!Cast<String_Constant>(list_item)) {
             continue;
           }
         }
@@ -415,19 +435,29 @@ namespace Sass {
 
     in_comma_array = was_comma_array;
     in_space_array = was_space_array;
+
+    // if the list is bracketed, always include the right bracket
+    if (list->is_bracketed()) {
+      if (list->separator() == SASS_COMMA && list->size() == 1) {
+        append_string(",");
+      }
+      append_string(rbracket(list));
+    }
     // probably ruby sass eqivalent of element_needs_parens
-    if (output_style() == TO_SASS &&
+    else if (output_style() == TO_SASS &&
         list->length() == 1 &&
         !list->from_selector() &&
-        !SASS_MEMORY_CAST(List, list->at(0)) &&
-        !SASS_MEMORY_CAST(Selector_List, list->at(0))) {
-      append_string(",)");
+        !Cast<List>(list->at(0)) &&
+        !Cast<Selector_List>(list->at(0))
+    ) {
+      append_string(",");
+      append_string(rbracket(list));
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
         (list->separator() == SASS_SPACE && in_space_array) ||
         (list->separator() == SASS_COMMA && in_comma_array)
     )) {
-      append_string(")");
+      append_string(rbracket(list));
     }
 
   }
@@ -443,7 +473,7 @@ namespace Sass {
               expr->is_right_interpolant())
 
     )) append_string(" ");
-    switch (expr->type()) {
+    switch (expr->optype()) {
       case Sass_OP::AND: append_string("&&"); break;
       case Sass_OP::OR:  append_string("||");  break;
       case Sass_OP::EQ:  append_string("==");  break;
@@ -471,8 +501,9 @@ namespace Sass {
 
   void Inspect::operator()(Unary_Expression_Ptr expr)
   {
-    if (expr->type() == Unary_Expression::PLUS) append_string("+");
-    else                                        append_string("-");
+    if (expr->optype() == Unary_Expression::PLUS)       append_string("+");
+    else if (expr->optype() == Unary_Expression::SLASH) append_string("/");
+    else                                                append_string("-");
     expr->operand()->perform(this);
   }
 
@@ -493,16 +524,14 @@ namespace Sass {
     append_token(var->name(), var);
   }
 
-  void Inspect::operator()(Textual_Ptr txt)
-  {
-    append_token(txt->value(), txt);
-  }
-
   void Inspect::operator()(Number_Ptr n)
   {
 
     std::string res;
 
+    // reduce units
+    n->reduce();
+
     // check if the fractional part of the value equals to zero
     // neat trick from http://stackoverflow.com/a/1521682/1550314
     // double int_part; bool is_int = modf(value, &int_part) == 0.0;
@@ -600,6 +629,11 @@ namespace Sass {
     // maybe an unknown token
     std::string name = c->disp();
 
+    if (opt.in_selector && name != "") {
+      append_token(name, c);
+      return;
+    }
+
     // resolved color
     std::string res_name = name;
 
@@ -624,6 +658,9 @@ namespace Sass {
     }
 
     std::stringstream hexlet;
+    // dart sass compressed all colors in regular css always
+    // ruby sass and libsass does it only when not delayed
+    // since color math is going to be removed, this can go too
     bool compressed = opt.output_style == COMPRESSED;
     hexlet << '#' << std::setw(1) << std::setfill('0');
     // create a short color hexlet if there is any need for it
@@ -647,9 +684,6 @@ namespace Sass {
     if (name != "") {
       ss << name;
     }
-    else if (r == 0 && g == 0 && b == 0 && a == 0) {
-        ss << "transparent";
-    }
     else if (a >= 1) {
       if (res_name != "") {
         if (compressed && hexlet.str().size() < res_name.size()) {
@@ -744,9 +778,9 @@ namespace Sass {
   {
     append_token("not", sn);
     append_mandatory_space();
-    if (sn->needs_parens(&sn->condition())) append_string("(");
+    if (sn->needs_parens(sn->condition())) append_string("(");
     sn->condition()->perform(this);
-    if (sn->needs_parens(&sn->condition())) append_string(")");
+    if (sn->needs_parens(sn->condition())) append_string(")");
   }
 
   void Inspect::operator()(Supports_Declaration_Ptr sd)
@@ -766,7 +800,7 @@ namespace Sass {
   void Inspect::operator()(Media_Query_Ptr mq)
   {
     size_t i = 0;
-    if (&mq->media_type()) {
+    if (mq->media_type()) {
       if      (mq->is_negated())    append_string("not ");
       else if (mq->is_restricted()) append_string("only ");
       mq->media_type()->perform(this);
@@ -798,12 +832,22 @@ namespace Sass {
 
   void Inspect::operator()(At_Root_Query_Ptr ae)
   {
-    append_string("(");
-    ae->feature()->perform(this);
-    if (ae->value()) {
-      append_colon_separator();
-      ae->value()->perform(this);
+    if (ae->feature()) {
+      append_string("(");
+      ae->feature()->perform(this);
+      if (ae->value()) {
+        append_colon_separator();
+        ae->value()->perform(this);
+      }
+      append_string(")");
     }
+  }
+
+  void Inspect::operator()(Function_Ptr f)
+  {
+    append_token("get-function", f);
+    append_string("(");
+    append_string(quote(f->name()));
     append_string(")");
   }
 
@@ -851,7 +895,7 @@ namespace Sass {
       return;
     }
     if (a->value()->concrete_type() == Expression::STRING) {
-      String_Constant_Ptr s = SASS_MEMORY_CAST(String_Constant, a->value());
+      String_Constant_Ptr s = Cast<String_Constant>(a->value());
       if (s) s->perform(this);
     } else {
       a->value()->perform(this);
@@ -877,7 +921,9 @@ namespace Sass {
 
   void Inspect::operator()(Selector_Schema_Ptr s)
   {
+    opt.in_selector = true;
     s->contents()->perform(this);
+    opt.in_selector = false;
   }
 
   void Inspect::operator()(Parent_Selector_Ptr p)
@@ -919,11 +965,15 @@ namespace Sass {
     append_token(s->ns_name(), s);
     if (!s->matcher().empty()) {
       append_string(s->matcher());
-      if (&s->value() && *s->value()) {
+      if (s->value() && *s->value()) {
         s->value()->perform(this);
       }
     }
     add_close_mapping(s);
+    if (s->modifier() != 0) {
+      append_mandatory_space();
+      append_char(s->modifier());
+    }
     append_string("]");
   }
 
@@ -939,16 +989,20 @@ namespace Sass {
 
   void Inspect::operator()(Wrapped_Selector_Ptr s)
   {
-    bool was = in_wrapped;
-    in_wrapped = true;
-    append_token(s->name(), s);
-    append_string("(");
-    bool was_comma_array = in_comma_array;
-    in_comma_array = false;
-    s->selector()->perform(this);
-    in_comma_array = was_comma_array;
-    append_string(")");
-    in_wrapped = was;
+    if (s->name() == " ") {
+      append_string("");
+    } else {
+      bool was = in_wrapped;
+      in_wrapped = true;
+      append_token(s->name(), s);
+      append_string("(");
+      bool was_comma_array = in_comma_array;
+      in_comma_array = false;
+      s->selector()->perform(this);
+      in_comma_array = was_comma_array;
+      append_string(")");
+      in_wrapped = was;
+    }
   }
 
   void Inspect::operator()(Compound_Selector_Ptr s)
@@ -1014,6 +1068,7 @@ namespace Sass {
         if (tail) append_mandatory_space();
         else append_optional_space();
       break;
+      default: break;
     }
     if (tail && comb != Complex_Selector::ANCESTOR_OF) {
       if (c->has_line_break()) append_optional_linefeed();
@@ -1040,8 +1095,8 @@ namespace Sass {
     bool was_comma_array = in_comma_array;
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
-      (!SASS_MEMORY_CAST(List, (*g)[0]) &&
-       !SASS_MEMORY_CAST(Selector_List, (*g)[0]))) {
+      (!Cast<List>((*g)[0]) &&
+       !Cast<Selector_List>((*g)[0]))) {
       append_string("(");
     }
     else if (!in_declaration && in_comma_array) {
@@ -1053,7 +1108,7 @@ namespace Sass {
     for (size_t i = 0, L = g->length(); i < L; ++i) {
       if (!in_wrapped && i == 0) append_indentation();
       if ((*g)[i] == 0) continue;
-      schedule_mapping(&g->at(i)->last());
+      schedule_mapping(g->at(i)->last());
       // add_open_mapping((*g)[i]->last());
       (*g)[i]->perform(this);
       // add_close_mapping((*g)[i]->last());
@@ -1066,8 +1121,8 @@ namespace Sass {
     in_comma_array = was_comma_array;
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
-      (!SASS_MEMORY_CAST(List, (*g)[0]) &&
-       !SASS_MEMORY_CAST(Selector_List, (*g)[0]))) {
+      (!Cast<List>((*g)[0]) &&
+       !Cast<Selector_List>((*g)[0]))) {
       append_string(",)");
     }
     else if (!in_declaration && in_comma_array) {

data/ext/libsass/src/inspect.hpp

@@ -17,7 +17,7 @@ namespace Sass {
 
   public:
 
-    Inspect(Emitter emi);
+    Inspect(const Emitter& emi);
     virtual ~Inspect();
 
     // statements
@@ -48,6 +48,7 @@ namespace Sass {
     virtual void operator()(Content_Ptr);
     // expressions
     virtual void operator()(Map_Ptr);
+    virtual void operator()(Function_Ptr);
     virtual void operator()(List_Ptr);
     virtual void operator()(Binary_Expression_Ptr);
     virtual void operator()(Unary_Expression_Ptr);
@@ -56,7 +57,6 @@ namespace Sass {
     // virtual void operator()(Custom_Warning_Ptr);
     // virtual void operator()(Custom_Error_Ptr);
     virtual void operator()(Variable_Ptr);
-    virtual void operator()(Textual_Ptr);
     virtual void operator()(Number_Ptr);
     virtual void operator()(Color_Ptr);
     virtual void operator()(Boolean_Ptr);
@@ -92,6 +92,9 @@ namespace Sass {
     virtual void operator()(Complex_Selector_Ptr);
     virtual void operator()(Selector_List_Ptr);
 
+    virtual std::string lbracket(List_Ptr);
+    virtual std::string rbracket(List_Ptr);
+
     // template <typename U>
     // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node_Ptr>(x)); }
   };