sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/{functions.hpp → src/functions.hpp}

@@ -1,11 +1,9 @@
 #ifndef SASS_FUNCTIONS_H
 #define SASS_FUNCTIONS_H
 
-#include <string>
-
 #include "position.hpp"
 #include "environment.hpp"
-#include "sass_functions.h"
+#include "sass/functions.h"
 
 #define BUILT_IN(name) Expression*\
 name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtrace* backtrace)
@@ -23,6 +21,8 @@ namespace Sass {
   Definition* make_native_function(Signature, Native_Function, Context& ctx);
   Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx);
 
+  std::string function_name(Signature);
+
   namespace Functions {
 
     extern Signature rgb_sig;
@@ -101,7 +101,14 @@ namespace Sass {
     extern Signature keywords_sig;
     extern Signature set_nth_sig;
     extern Signature unique_id_sig;
+    extern Signature selector_nest_sig;
+    extern Signature selector_append_sig;
+    extern Signature selector_extend_sig;
+    extern Signature selector_replace_sig;
+    extern Signature selector_unify_sig;
     extern Signature is_superselector_sig;
+    extern Signature simple_selectors_sig;
+    extern Signature selector_parse_sig;
 
     BUILT_IN(rgb);
     BUILT_IN(rgba_4);
@@ -176,8 +183,14 @@ namespace Sass {
     BUILT_IN(keywords);
     BUILT_IN(set_nth);
     BUILT_IN(unique_id);
+    BUILT_IN(selector_nest);
+    BUILT_IN(selector_append);
+    BUILT_IN(selector_extend);
+    BUILT_IN(selector_replace);
+    BUILT_IN(selector_unify);
     BUILT_IN(is_superselector);
-
+    BUILT_IN(simple_selectors);
+    BUILT_IN(selector_parse);
   }
 }
 

data/ext/libsass/{inspect.cpp → src/inspect.cpp}

@@ -8,10 +8,11 @@
 #include "ast.hpp"
 #include "inspect.hpp"
 #include "context.hpp"
+#include "listize.hpp"
+#include "color_maps.hpp"
 #include "utf8/checked.h"
 
 namespace Sass {
-  using namespace std;
 
   Inspect::Inspect(Emitter emi)
   : Emitter(emi)
@@ -76,12 +77,12 @@ namespace Sass {
     media_block->block()->perform(this);
   }
 
-  void Inspect::operator()(Feature_Block* feature_block)
+  void Inspect::operator()(Supports_Block* feature_block)
   {
     append_indentation();
     append_token("@supports", feature_block);
     append_mandatory_space();
-    feature_block->feature_queries()->perform(this);
+    feature_block->condition()->perform(this);
     feature_block->block()->perform(this);
   }
 
@@ -105,6 +106,10 @@ namespace Sass {
       at_rule->selector()->perform(this);
       in_wrapped = was_wrapped;
     }
+    if (at_rule->value()) {
+      append_mandatory_space();
+      at_rule->value()->perform(this);
+    }
     if (at_rule->block()) {
       at_rule->block()->perform(this);
     }
@@ -123,7 +128,14 @@ namespace Sass {
     append_indentation();
     dec->property()->perform(this);
     append_colon_separator();
-    dec->value()->perform(this);
+
+    if (dec->value()->concrete_type() == Expression::SELECTOR) {
+      Listize listize(*ctx);
+      dec->value()->perform(&listize)->perform(this);
+    } else {
+      dec->value()->perform(this);
+    }
+
     if (dec->is_important()) {
       append_optional_space();
       append_string("!important");
@@ -157,6 +169,10 @@ namespace Sass {
       }
 
       import->urls().front()->perform(this);
+      if (import->media_queries()) {
+        append_mandatory_space();
+        import->media_queries()->perform(this);
+      }
       append_delimiter();
       for (size_t i = 1, S = import->urls().size(); i < S; ++i) {
         append_mandatory_linefeed();
@@ -168,6 +184,10 @@ namespace Sass {
         }
 
         import->urls()[i]->perform(this);
+        if (import->media_queries()) {
+          append_mandatory_space();
+          import->media_queries()->perform(this);
+        }
         append_delimiter();
       }
     }
@@ -222,7 +242,7 @@ namespace Sass {
     append_token("@if", cond);
     append_mandatory_space();
     cond->predicate()->perform(this);
-    cond->consequent()->perform(this);
+    cond->block()->perform(this);
     if (cond->alternative()) {
       append_optional_linefeed();
       append_indentation();
@@ -331,8 +351,6 @@ namespace Sass {
     bool items_output = false;
     append_string("(");
     for (auto key : map->keys()) {
-      if (key->is_invisible()) continue;
-      if (map->at(key)->is_invisible()) continue;
       if (items_output) append_comma_separator();
       key->perform(this);
       append_colon_separator();
@@ -344,7 +362,7 @@ namespace Sass {
 
   void Inspect::operator()(List* list)
   {
-    string sep(list->separator() == List::SPACE ? " " : ",");
+    std::string sep(list->separator() == SASS_SPACE ? " " : ",");
     if (output_style() != COMPRESSED && sep == ",") sep += " ";
     else if (in_media_block && sep != " ") sep += " "; // verified
     if (list->empty()) return;
@@ -353,14 +371,14 @@ namespace Sass {
     bool was_space_array = in_space_array;
     bool was_comma_array = in_comma_array;
     if (!in_declaration && (
-        (list->separator() == List::SPACE && in_space_array) ||
-        (list->separator() == List::COMMA && in_comma_array)
+        (list->separator() == SASS_SPACE && in_space_array) ||
+        (list->separator() == SASS_COMMA && in_comma_array)
     )) {
       append_string("(");
     }
 
-    if (list->separator() == List::SPACE) in_space_array = true;
-    else if (list->separator() == List::COMMA) in_comma_array = true;
+    if (list->separator() == SASS_SPACE) in_space_array = true;
+    else if (list->separator() == SASS_COMMA) in_comma_array = true;
 
     for (size_t i = 0, L = list->size(); i < L; ++i) {
       Expression* list_item = (*list)[i];
@@ -379,8 +397,8 @@ namespace Sass {
     in_comma_array = was_comma_array;
     in_space_array = was_space_array;
     if (!in_declaration && (
-        (list->separator() == List::SPACE && in_space_array) ||
-        (list->separator() == List::COMMA && in_comma_array)
+        (list->separator() == SASS_SPACE && in_space_array) ||
+        (list->separator() == SASS_COMMA && in_comma_array)
     )) {
       append_string(")");
     }
@@ -391,19 +409,19 @@ namespace Sass {
   {
     expr->left()->perform(this);
     switch (expr->type()) {
-      case Binary_Expression::AND: append_string(" and "); break;
-      case Binary_Expression::OR:  append_string(" or ");  break;
-      case Binary_Expression::EQ:  append_string(" == ");  break;
-      case Binary_Expression::NEQ: append_string(" != ");  break;
-      case Binary_Expression::GT:  append_string(" > ");   break;
-      case Binary_Expression::GTE: append_string(" >= ");  break;
-      case Binary_Expression::LT:  append_string(" < ");   break;
-      case Binary_Expression::LTE: append_string(" <= ");  break;
-      case Binary_Expression::ADD: append_string(" + ");   break;
-      case Binary_Expression::SUB: append_string(" - ");   break;
-      case Binary_Expression::MUL: append_string(" * ");   break;
-      case Binary_Expression::DIV: append_string("/");     break;
-      case Binary_Expression::MOD: append_string(" % ");   break;
+      case Sass_OP::AND: append_string(" and "); break;
+      case Sass_OP::OR:  append_string(" or ");  break;
+      case Sass_OP::EQ:  append_string(" == ");  break;
+      case Sass_OP::NEQ: append_string(" != ");  break;
+      case Sass_OP::GT:  append_string(" > ");   break;
+      case Sass_OP::GTE: append_string(" >= ");  break;
+      case Sass_OP::LT:  append_string(" < ");   break;
+      case Sass_OP::LTE: append_string(" <= ");  break;
+      case Sass_OP::ADD: append_string(" + ");   break;
+      case Sass_OP::SUB: append_string(" - ");   break;
+      case Sass_OP::MUL: append_string(" * ");   break;
+      case Sass_OP::DIV: append_string(in_media_block ? " / " : "/"); break;
+      case Sass_OP::MOD: append_string(" % ");   break;
       default: break; // shouldn't get here
     }
     expr->right()->perform(this);
@@ -440,191 +458,35 @@ namespace Sass {
 
   void Inspect::operator()(Number* n)
   {
-
-    string res;
-
-    // init stuff
-    n->normalize();
-    int precision = 5;
-    double value = n->value();
-    // get option from optional context
-    if (ctx) precision = ctx->precision;
-
-    // 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;
-
-    // this all cannot be done with one run only, since fixed
-    // output differs from normal output and regular output
-    // can contain scientific notation which we do not want!
-
-    // first sample
-    stringstream ss;
-    ss.precision(12);
-    ss << value;
-
-    // check if we got scientific notation in result
-    if (ss.str().find_first_of("e") != string::npos) {
-      ss.clear(); ss.str(string());
-      ss.precision(max(12, precision));
-      ss << fixed << value;
-    }
-
-    string tmp = ss.str();
-    size_t pos_point = tmp.find_first_of(".,");
-    size_t pos_fract = tmp.find_last_not_of("0");
-    bool is_int = pos_point == pos_fract ||
-                  pos_point == string::npos;
-
-    // reset stream for another run
-    ss.clear(); ss.str(string());
-
-    // take a shortcut for integers
-    if (is_int)
-    {
-      ss.precision(0);
-      ss << fixed << value;
-      res = string(ss.str());
-    }
-    // process floats
-    else
-    {
-      // do we have have too much precision?
-      if (pos_fract < precision + pos_point)
-      { precision = pos_fract - pos_point; }
-      // round value again
-      ss.precision(precision);
-      ss << fixed << value;
-      res = string(ss.str());
-      // maybe we truncated up to decimal point
-      size_t pos = res.find_last_not_of("0");
-      bool at_dec_point = res[pos] == '.' ||
-                          res[pos] == ',';
-      // don't leave a blank point
-      if (at_dec_point) ++ pos;
-      res.resize (pos + 1);
-    }
-
-    // some final cosmetics
-    if (res == "-0.0") res.erase(0, 1);
-    else if (res == "-0") res.erase(0, 1);
-
-    // add unit now
-    res += n->unit();
-
-    // check for a valid unit here
-    // includes result for reporting
-    if (n->numerator_units().size() > 1 ||
-        n->denominator_units().size() > 0 ||
-        (n->numerator_units().size() && n->numerator_units()[0].find_first_of('/') != string::npos) ||
-        (n->numerator_units().size() && n->numerator_units()[0].find_first_of('*') != string::npos)
-    ) {
-      error(res + " isn't a valid CSS value.", n->pstate());
-    }
-
+    // use values to_string facility
+    bool compressed = ctx->output_style == COMPRESSED;
+    std::string res = n->to_string(compressed, (int)ctx->precision);
     // output the final token
     append_token(res, n);
-
-  }
-
-  // helper function for serializing colors
-  template <size_t range>
-  static double cap_channel(double c) {
-    if      (c > range) return range;
-    else if (c < 0)     return 0;
-    else                return c;
   }
 
   void Inspect::operator()(Color* c)
   {
-    stringstream ss;
-
-    // check if we prefer short hex colors
-    bool want_short = output_style() == COMPRESSED;
-
-    // original color name
-    // maybe an unknown token
-    string name = c->disp();
-
-    // resolved color
-    string res_name = name;
-
-    double r = round(cap_channel<0xff>(c->r()));
-    double g = round(cap_channel<0xff>(c->g()));
-    double b = round(cap_channel<0xff>(c->b()));
-    double a = cap_channel<1>   (c->a());
-
-    // get color from given name (if one was given at all)
-    if (name != "" && ctx && ctx->names_to_colors.count(name)) {
-      Color* n = ctx->names_to_colors[name];
-      r = round(cap_channel<0xff>(n->r()));
-      g = round(cap_channel<0xff>(n->g()));
-      b = round(cap_channel<0xff>(n->b()));
-      a = cap_channel<1>   (n->a());
-    }
-    // otherwise get the possible resolved color name
-    else {
-      int numval = static_cast<int>(r) * 0x10000 + static_cast<int>(g) * 0x100 + static_cast<int>(b);
-      if (ctx && ctx->colors_to_names.count(numval))
-        res_name = ctx->colors_to_names[numval];
-    }
-
-    stringstream hexlet;
-    hexlet << '#' << setw(1) << setfill('0');
-    // create a short color hexlet if there is any need for it
-    if (want_short && is_color_doublet(r, g, b) && a == 1) {
-      hexlet << hex << setw(1) << (static_cast<unsigned long>(r) >> 4);
-      hexlet << hex << setw(1) << (static_cast<unsigned long>(g) >> 4);
-      hexlet << hex << setw(1) << (static_cast<unsigned long>(b) >> 4);
-    } else {
-      hexlet << hex << setw(2) << static_cast<unsigned long>(r);
-      hexlet << hex << setw(2) << static_cast<unsigned long>(g);
-      hexlet << hex << setw(2) << static_cast<unsigned long>(b);
-    }
-
-    if (want_short && !c->is_delayed()) name = "";
-
-    // retain the originally specified color definition if unchanged
-    if (name != "") {
-      ss << name;
-    }
-    else if (r == 0 && g == 0 && b == 0 && a == 0) {
-        ss << "transparent";
-    }
-    else if (a >= 1) {
-      if (res_name != "") {
-        if (want_short && hexlet.str().size() < res_name.size()) {
-          ss << hexlet.str();
-        } else {
-          ss << res_name;
-        }
-      }
-      else {
-        ss << hexlet.str();
-      }
-    }
-    else {
-      ss << "rgba(";
-      ss << static_cast<unsigned long>(r) << ",";
-      if (output_style() != COMPRESSED) ss << " ";
-      ss << static_cast<unsigned long>(g) << ",";
-      if (output_style() != COMPRESSED) ss << " ";
-      ss << static_cast<unsigned long>(b) << ",";
-      if (output_style() != COMPRESSED) ss << " ";
-      ss << a << ')';
-    }
-    append_token(ss.str(), c);
+    // use values to_string facility
+    bool compressed = ctx->output_style == COMPRESSED;
+	std::string res = c->to_string(compressed, (int)ctx->precision);
+    // output the final token
+    append_token(res, c);
   }
 
   void Inspect::operator()(Boolean* b)
   {
-    append_token(b->value() ? "true" : "false", b);
+    // use values to_string facility
+    bool compressed = ctx->output_style == COMPRESSED;
+	std::string res = b->to_string(compressed, (int)ctx->precision);
+    // output the final token
+    append_token(res, b);
   }
 
   void Inspect::operator()(String_Schema* ss)
   {
-    // Evaluation should turn these into String_Constants, so this method is
-    // only for inspection purposes.
+    // Evaluation should turn these into String_Constants,
+    // so this method is only for inspection purposes.
     for (size_t i = 0, L = ss->length(); i < L; ++i) {
       if ((*ss)[i]->is_interpolant()) append_string("#{");
       (*ss)[i]->perform(this);
@@ -634,57 +496,68 @@ namespace Sass {
 
   void Inspect::operator()(String_Constant* s)
   {
-    if (String_Quoted* quoted = dynamic_cast<String_Quoted*>(s)) {
-      return Inspect::operator()(quoted);
-    }
-    append_token(s->value(), s);
+    // get options from optional? context
+    int precision = ctx ? (int)ctx->precision : 5;
+    bool compressed = ctx ? ctx->output_style == COMPRESSED : false;
+    // use values to_string facility
+    std::string res(s->to_string(compressed, precision));
+    // output the final token
+    append_token(res, s);
   }
 
   void Inspect::operator()(String_Quoted* s)
   {
-    if (s->quote_mark()) {
-      append_token(quote(s->value(), s->quote_mark(), true), s);
-    } else {
-      append_token(s->value(), s);
-    }
+    // get options from optional? context
+    int precision = ctx ? (int)ctx->precision : 5;
+    bool compressed = ctx ? ctx->output_style == COMPRESSED : false;
+    // use values to_string facility
+    std::string res(s->to_string(compressed, precision));
+    // output the final token
+    append_token(res, s);
   }
-
-  void Inspect::operator()(Feature_Query* fq)
+  void Inspect::operator()(Supports_Operator* so)
   {
-    size_t i = 0;
-    (*fq)[i++]->perform(this);
-    for (size_t L = fq->length(); i < L; ++i) {
-      (*fq)[i]->perform(this);
-    }
-  }
 
-  void Inspect::operator()(Feature_Query_Condition* fqc)
-  {
-    if (fqc->operand() == Feature_Query_Condition::AND) {
-      append_mandatory_space();
-      append_token("and", fqc);
-      append_mandatory_space();
-    } else if (fqc->operand() == Feature_Query_Condition::OR) {
+    if (so->needs_parens(so->left())) append_string("(");
+    so->left()->perform(this);
+    if (so->needs_parens(so->left())) append_string(")");
+
+    if (so->operand() == Supports_Operator::AND) {
       append_mandatory_space();
-      append_token("or", fqc);
+      append_token("and", so);
       append_mandatory_space();
-    } else if (fqc->operand() == Feature_Query_Condition::NOT) {
+    } else if (so->operand() == Supports_Operator::OR) {
       append_mandatory_space();
-      append_token("not", fqc);
+      append_token("or", so);
       append_mandatory_space();
     }
 
-    if (!fqc->is_root()) append_string("(");
+    if (so->needs_parens(so->right())) append_string("(");
+    so->right()->perform(this);
+    if (so->needs_parens(so->right())) append_string(")");
+  }
 
-    if (!fqc->length()) {
-      fqc->feature()->perform(this);
-      append_string(": "); // verified
-      fqc->value()->perform(this);
-    }
-    for (size_t i = 0, L = fqc->length(); i < L; ++i)
-      (*fqc)[i]->perform(this);
+  void Inspect::operator()(Supports_Negation* sn)
+  {
+    append_token("not", sn);
+    append_mandatory_space();
+    if (sn->needs_parens(sn->condition())) append_string("(");
+    sn->condition()->perform(this);
+    if (sn->needs_parens(sn->condition())) append_string(")");
+  }
 
-    if (!fqc->is_root()) append_string(")");
+  void Inspect::operator()(Supports_Declaration* sd)
+  {
+    append_string("(");
+    sd->feature()->perform(this);
+    append_string(": ");
+    sd->value()->perform(this);
+    append_string(")");
+  }
+
+  void Inspect::operator()(Supports_Interpolation* sd)
+  {
+    sd->value()->perform(this);
   }
 
   void Inspect::operator()(Media_Query* mq)
@@ -738,18 +611,11 @@ namespace Sass {
 
   void Inspect::operator()(Null* n)
   {
-    append_token("null", n);
-  }
-
-  void Inspect::operator()(Parent_Selector* p)
-  {
-    if (p->selector()) {
-      p->selector()->perform(this);
-      append_delimiter();
-    }
-    else {
-      append_string("&");
-    }
+    // use values to_string facility
+    bool compressed = ctx->output_style == COMPRESSED;
+    std::string res = n->to_string(compressed, (int)ctx->precision);
+    // output the final token
+    append_token(res, n);
   }
 
   // parameters and arguments
@@ -816,10 +682,9 @@ namespace Sass {
     s->contents()->perform(this);
   }
 
-  void Inspect::operator()(Selector_Reference* ref)
+  void Inspect::operator()(Parent_Selector* p)
   {
-    if (ref->selector()) ref->selector()->perform(this);
-    else                 append_string("&");
+    append_string("&");
   }
 
   void Inspect::operator()(Selector_Placeholder* s)
@@ -832,12 +697,12 @@ namespace Sass {
 
   void Inspect::operator()(Type_Selector* s)
   {
-    append_token(s->name(), s);
+    append_token(s->ns_name(), s);
   }
 
   void Inspect::operator()(Selector_Qualifier* s)
   {
-    append_token(s->name(), s);
+    append_token(s->ns_name(), s);
     if (s->has_line_break()) append_optional_linefeed();
     if (s->has_line_break()) append_indentation();
   }
@@ -846,7 +711,7 @@ namespace Sass {
   {
     append_string("[");
     add_open_mapping(s);
-    append_token(s->name(), s);
+    append_token(s->ns_name(), s);
     if (!s->matcher().empty()) {
       append_string(s->matcher());
       if (s->value()) {
@@ -859,8 +724,9 @@ namespace Sass {
 
   void Inspect::operator()(Pseudo_Selector* s)
   {
-    append_token(s->name(), s);
+    append_token(s->ns_name(), s);
     if (s->expression()) {
+      append_string("(");
       s->expression()->perform(this);
       append_string(")");
     }
@@ -871,6 +737,7 @@ namespace Sass {
     bool was = in_wrapped;
     in_wrapped = true;
     append_token(s->name(), s);
+    append_string("(");
     s->selector()->perform(this);
     append_string(")");
     in_wrapped = was;
@@ -882,7 +749,9 @@ namespace Sass {
       (*s)[i]->perform(this);
     }
     if (s->has_line_break()) {
-      append_optional_linefeed();
+      if (output_style() != COMPACT) {
+        append_optional_linefeed();
+      }
     }
   }
 
@@ -891,8 +760,16 @@ namespace Sass {
     Compound_Selector*           head = c->head();
     Complex_Selector*            tail = c->tail();
     Complex_Selector::Combinator comb = c->combinator();
-    if (head && !head->is_empty_reference()) head->perform(this);
-    bool is_empty = head && head->is_empty_reference();
+
+    if (c->has_line_feed()) {
+      if (!(c->has_parent_ref())) {
+        append_optional_linefeed();
+        append_indentation();
+      }
+    }
+
+    if (head && head->length() != 0) head->perform(this);
+    bool is_empty = !head || head->length() == 0 || head->is_empty_reference();
     bool is_tail = head && !head->is_empty_reference() && tail;
     if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;
 
@@ -910,6 +787,13 @@ namespace Sass {
         append_string("+");
         append_optional_space();
       break;
+      case Complex_Selector::REFERENCE:
+        append_mandatory_space();
+        append_string("/");
+        c->reference()->perform(this);
+        append_string("/");
+        append_mandatory_space();
+      break;
       case Complex_Selector::PRECEDES:
         if (is_empty) append_optional_space();
         else append_mandatory_space();
@@ -922,6 +806,11 @@ namespace Sass {
       if (c->has_line_break()) append_optional_linefeed();
     }
     if (tail) tail->perform(this);
+    if (!tail && c->has_line_break()) {
+      if (output_style() == COMPACT) {
+        append_mandatory_space();
+      }
+    }
   }
 
   void Inspect::operator()(Selector_List* g)
@@ -929,13 +818,11 @@ namespace Sass {
     if (g->empty()) return;
     for (size_t i = 0, L = g->length(); i < L; ++i) {
       if (!in_wrapped && i == 0) append_indentation();
+      if ((*g)[i] == 0) continue;
       (*g)[i]->perform(this);
       if (i < L - 1) {
+        scheduled_space = 0;
         append_comma_separator();
-        if ((*g)[i]->has_line_feed()) {
-          append_optional_linefeed();
-          append_indentation();
-        }
       }
     }
   }