sassc 0.0.9 → 0.0.10

data/ext/libsass/functions.hpp

@@ -1,29 +1,24 @@
-#define SASS_FUNCTIONS
+#ifndef SASS_FUNCTIONS_H
+#define SASS_FUNCTIONS_H
 
 #include <string>
 
-#ifndef SASS_ENVIRONMENT
-#include "environment.hpp"
-#endif
-
-#ifndef SASS_POSITION
 #include "position.hpp"
-#endif
-
+#include "environment.hpp"
 #include "sass_functions.h"
 
 #define BUILT_IN(name) Expression*\
-name(Env& env, Env& d_env, Context& ctx, Signature sig, const string& path, Position position, Backtrace* backtrace)
+name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtrace* backtrace)
 
 namespace Sass {
-  struct Context;
+  class Context;
   struct Backtrace;
   class AST_Node;
   class Expression;
   class Definition;
   typedef Environment<AST_Node*> Env;
   typedef const char* Signature;
-  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, const string&, Position, Backtrace*);
+  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*);
 
   Definition* make_native_function(Signature, Native_Function, Context&);
   Definition* make_c_function(Signature sig, Sass_C_Function f, void* cookie, Context& ctx);
@@ -185,3 +180,5 @@ namespace Sass {
 
   }
 }
+
+#endif

data/ext/libsass/inspect.cpp

@@ -1,43 +1,39 @@
 #include "inspect.hpp"
 #include "ast.hpp"
 #include "context.hpp"
+#include "utf8/checked.h"
 #include <cmath>
+#include <string>
 #include <iostream>
 #include <iomanip>
+#include <stdint.h>
+#include <stdint.h>
 
 namespace Sass {
   using namespace std;
 
-  Inspect::Inspect(Context* ctx) : buffer(""), indentation(0), ctx(ctx) { }
+  Inspect::Inspect(Emitter emi)
+  : Emitter(emi)
+  { }
   Inspect::~Inspect() { }
 
   // statements
   void Inspect::operator()(Block* block)
   {
     if (!block->is_root()) {
-      append_to_buffer(" {\n");
-      ++indentation;
+      add_open_mapping(block);
+      append_scope_opener();
     }
+    if (output_style() == NESTED) indentation += block->tabs();
     for (size_t i = 0, L = block->length(); i < L; ++i) {
-      indent();
       (*block)[i]->perform(this);
-      // extra newline at the end of top-level statements
-      if (block->is_root()) append_to_buffer("\n");
-      append_to_buffer("\n");
     }
+    if (output_style() == NESTED) indentation -= block->tabs();
     if (!block->is_root()) {
-      --indentation;
-      indent();
-      append_to_buffer("}");
-    }
-    // remove extra newline that gets added after the last top-level block
-    if (block->is_root()) {
-      size_t l = buffer.length();
-      if (l > 2 && buffer[l-1] == '\n' && buffer[l-2] == '\n') {
-        buffer.erase(l-1);
-        if (ctx) ctx->source_map.remove_line();
-      }
+      append_scope_closer();
+      add_close_mapping(block);
     }
+
   }
 
   void Inspect::operator()(Ruleset* ruleset)
@@ -46,206 +42,288 @@ namespace Sass {
     ruleset->block()->perform(this);
   }
 
+  void Inspect::operator()(Keyframe_Rule* rule)
+  {
+    append_indentation();
+    if (rule->rules()) rule->rules()->perform(this);
+    rule->block()->perform(this);
+  }
+
   void Inspect::operator()(Propset* propset)
   {
     propset->property_fragment()->perform(this);
-    append_to_buffer(": ");
+    append_colon_separator();
     propset->block()->perform(this);
   }
 
+  void Inspect::operator()(Bubble* bubble)
+  {
+    append_indentation();
+    append_token("Bubble", bubble);
+    append_optional_space();
+    append_string("(");
+    append_optional_space();
+    bubble->node()->perform(this);
+    append_optional_space();
+    append_string(")");
+    append_optional_space();
+  }
+
   void Inspect::operator()(Media_Block* media_block)
   {
-    if (ctx) ctx->source_map.add_mapping(media_block);
-    append_to_buffer("@media ");
+    append_indentation();
+    append_token("@media", media_block);
+    append_mandatory_space();
+    in_media_block = true;
     media_block->media_queries()->perform(this);
+    in_media_block = false;
     media_block->block()->perform(this);
   }
 
   void Inspect::operator()(Feature_Block* feature_block)
   {
-    if (ctx) ctx->source_map.add_mapping(feature_block);
-    append_to_buffer("@supports ");
+    append_indentation();
+    append_token("@supports", feature_block);
+    append_mandatory_space();
     feature_block->feature_queries()->perform(this);
     feature_block->block()->perform(this);
   }
 
+  void Inspect::operator()(At_Root_Block* at_root_block)
+  {
+    append_indentation();
+    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);
+  }
+
   void Inspect::operator()(At_Rule* at_rule)
   {
-    append_to_buffer(at_rule->keyword());
+    append_indentation();
+    append_token(at_rule->keyword(), at_rule);
     if (at_rule->selector()) {
-      append_to_buffer(" ");
+      append_mandatory_space();
+      in_at_rule = true;
       at_rule->selector()->perform(this);
+      in_at_rule = false;
     }
     if (at_rule->block()) {
       at_rule->block()->perform(this);
     }
     else {
-      append_to_buffer(";");
+      append_delimiter();
     }
   }
 
   void Inspect::operator()(Declaration* dec)
   {
     if (dec->value()->concrete_type() == Expression::NULL_VAL) return;
-    if (ctx) ctx->source_map.add_mapping(dec->property());
+    in_declaration = true;
+    if (output_style() == NESTED)
+      indentation += dec->tabs();
+    append_indentation();
     dec->property()->perform(this);
-    append_to_buffer(": ");
-    if (ctx) ctx->source_map.add_mapping(dec->value());
+    append_colon_separator();
     dec->value()->perform(this);
-    if (dec->is_important()) append_to_buffer(" !important");
-    append_to_buffer(";");
+    if (dec->is_important()) {
+      append_optional_space();
+      append_string("!important");
+    }
+    append_delimiter();
+    if (output_style() == NESTED)
+      indentation -= dec->tabs();
+    in_declaration = false;
   }
 
   void Inspect::operator()(Assignment* assn)
   {
-    append_to_buffer(assn->variable());
-    append_to_buffer(": ");
+    append_token(assn->variable(), assn);
+    append_colon_separator();
     assn->value()->perform(this);
-    if (assn->is_guarded()) append_to_buffer(" !default");
-    append_to_buffer(";");
+    if (assn->is_guarded()) {
+      append_optional_space();
+      append_string("!default");
+    }
+    append_delimiter();
   }
 
   void Inspect::operator()(Import* import)
   {
     if (!import->urls().empty()) {
-      if (ctx) ctx->source_map.add_mapping(import);
-      append_to_buffer("@import ");
+      append_token("@import", import);
+      append_mandatory_space();
+
+      if (String_Quoted* strq = dynamic_cast<String_Quoted*>(import->urls().front())) {
+        strq->is_delayed(false);
+      }
+
       import->urls().front()->perform(this);
-      append_to_buffer(";");
+      append_delimiter();
       for (size_t i = 1, S = import->urls().size(); i < S; ++i) {
-        append_to_buffer("\n");
-        if (ctx) ctx->source_map.add_mapping(import);
-        append_to_buffer("@import ");
+        append_mandatory_linefeed();
+        append_token("@import", import);
+        append_mandatory_space();
+
+        if (String_Quoted* strq = dynamic_cast<String_Quoted*>(import->urls()[i])) {
+          strq->is_delayed(false);
+        }
+
         import->urls()[i]->perform(this);
-        append_to_buffer(";");
+        append_delimiter();
       }
     }
   }
 
   void Inspect::operator()(Import_Stub* import)
   {
-    if (ctx) ctx->source_map.add_mapping(import);
-    append_to_buffer("@import ");
-    append_to_buffer(import->file_name());
-    append_to_buffer(";");
+    append_indentation();
+    append_token("@import", import);
+    append_mandatory_space();
+    append_string(import->file_name());
+    append_delimiter();
   }
 
   void Inspect::operator()(Warning* warning)
   {
-    if (ctx) ctx->source_map.add_mapping(warning);
-    append_to_buffer("@warn ");
+    append_indentation();
+    append_token("@warn", warning);
+    append_mandatory_space();
     warning->message()->perform(this);
-    append_to_buffer(";");
+    append_delimiter();
   }
 
   void Inspect::operator()(Error* error)
   {
-    if (ctx) ctx->source_map.add_mapping(error);
-    append_to_buffer("@error ");
+    append_indentation();
+    append_token("@error", error);
+    append_mandatory_space();
     error->message()->perform(this);
-    append_to_buffer(";");
+    append_delimiter();
   }
 
   void Inspect::operator()(Debug* debug)
   {
-    if (ctx) ctx->source_map.add_mapping(debug);
-    append_to_buffer("@debug ");
+    append_indentation();
+    append_token("@debug", debug);
+    append_mandatory_space();
     debug->value()->perform(this);
-    append_to_buffer(";");
+    append_delimiter();
   }
 
   void Inspect::operator()(Comment* comment)
   {
+    in_comment = true;
     comment->text()->perform(this);
+    in_comment = false;
   }
 
   void Inspect::operator()(If* cond)
   {
-    append_to_buffer("@if ");
+    append_indentation();
+    append_token("@if", cond);
+    append_mandatory_space();
     cond->predicate()->perform(this);
     cond->consequent()->perform(this);
     if (cond->alternative()) {
-      append_to_buffer("\n");
-      indent();
-      append_to_buffer("else");
+      append_optional_linefeed();
+      append_indentation();
+      append_string("else");
       cond->alternative()->perform(this);
     }
   }
 
   void Inspect::operator()(For* loop)
   {
-    append_to_buffer("@for ");
-    append_to_buffer(loop->variable());
-    append_to_buffer(" from ");
+    append_indentation();
+    append_token("@for", loop);
+    append_mandatory_space();
+    append_string(loop->variable());
+    append_string(" from ");
     loop->lower_bound()->perform(this);
-    append_to_buffer((loop->is_inclusive() ? " through " : " to "));
+    append_string(loop->is_inclusive() ? " through " : " to ");
     loop->upper_bound()->perform(this);
     loop->block()->perform(this);
   }
 
   void Inspect::operator()(Each* loop)
   {
-    append_to_buffer("@each ");
-    append_to_buffer(loop->variables()[0]);
+    append_indentation();
+    append_token("@each", loop);
+    append_mandatory_space();
+    append_string(loop->variables()[0]);
     for (size_t i = 1, L = loop->variables().size(); i < L; ++i) {
-      append_to_buffer(", ");
-      append_to_buffer(loop->variables()[i]);
+      append_comma_separator();
+      append_string(loop->variables()[i]);
     }
-    append_to_buffer(" in ");
+    append_string(" in ");
     loop->list()->perform(this);
     loop->block()->perform(this);
   }
 
   void Inspect::operator()(While* loop)
   {
-    append_to_buffer("@while ");
+    append_indentation();
+    append_token("@while", loop);
+    append_mandatory_space();
     loop->predicate()->perform(this);
     loop->block()->perform(this);
   }
 
   void Inspect::operator()(Return* ret)
   {
-    append_to_buffer("@return ");
+    append_indentation();
+    append_token("@return", ret);
+    append_mandatory_space();
     ret->value()->perform(this);
-    append_to_buffer(";");
+    append_delimiter();
   }
 
   void Inspect::operator()(Extension* extend)
   {
-    append_to_buffer("@extend ");
+    append_indentation();
+    append_token("@extend", extend);
+    append_mandatory_space();
     extend->selector()->perform(this);
-    append_to_buffer(";");
+    append_delimiter();
   }
 
   void Inspect::operator()(Definition* def)
   {
+    append_indentation();
     if (def->type() == Definition::MIXIN) {
-      append_to_buffer("@mixin ");
+      append_token("@mixin", def);
+      append_mandatory_space();
     } else {
-      append_to_buffer("@function ");
+      append_token("@function", def);
+      append_mandatory_space();
     }
-    append_to_buffer(def->name());
+    append_string(def->name());
     def->parameters()->perform(this);
     def->block()->perform(this);
   }
 
   void Inspect::operator()(Mixin_Call* call)
   {
-    append_to_buffer(string("@include ") += call->name());
+    append_indentation();
+    append_token("@include", call);
+    append_mandatory_space();
+    append_string(call->name());
     if (call->arguments()) {
       call->arguments()->perform(this);
     }
     if (call->block()) {
-      append_to_buffer(" ");
+      append_optional_space();
       call->block()->perform(this);
     }
-    if (!call->block()) append_to_buffer(";");
+    if (!call->block()) append_delimiter();
   }
 
   void Inspect::operator()(Content* content)
   {
-    if (ctx) ctx->source_map.add_mapping(content);
-    append_to_buffer("@content;");
+    append_indentation();
+    append_token("@content", content);
+    append_delimiter();
   }
 
   void Inspect::operator()(Map* map)
@@ -253,52 +331,60 @@ namespace Sass {
     if (map->empty()) return;
     if (map->is_invisible()) return;
     bool items_output = false;
-    append_to_buffer("(");
+    append_string("(");
     for (auto key : map->keys()) {
       if (key->is_invisible()) continue;
       if (map->at(key)->is_invisible()) continue;
-      if (items_output) append_to_buffer(", ");
+      if (items_output) append_comma_separator();
       key->perform(this);
-      append_to_buffer(": ");
+      append_colon_separator();
       map->at(key)->perform(this);
       items_output = true;
     }
-    append_to_buffer(")");
+    append_string(")");
   }
 
   void Inspect::operator()(List* list)
   {
-    string sep(list->separator() == List::SPACE ? " " : ", ");
+    string sep(list->separator() == List::SPACE ? " " : ",");
+    if (output_style() != COMPRESSED && sep == ",") sep += " ";
+    else if (in_media_block && sep != " ") sep += " "; // verified
     if (list->empty()) return;
     bool items_output = false;
+    in_declaration_list = in_declaration;
     for (size_t i = 0, L = list->length(); i < L; ++i) {
       Expression* list_item = (*list)[i];
       if (list_item->is_invisible()) {
         continue;
       }
-      if (items_output) append_to_buffer(sep);
+      if (items_output) {
+        append_string(sep);
+      }
+      if (items_output && sep != " ")
+        append_optional_space();
       list_item->perform(this);
       items_output = true;
     }
+    in_declaration_list = false;
   }
 
   void Inspect::operator()(Binary_Expression* expr)
   {
     expr->left()->perform(this);
     switch (expr->type()) {
-      case Binary_Expression::AND: append_to_buffer(" and "); break;
-      case Binary_Expression::OR:  append_to_buffer(" or ");  break;
-      case Binary_Expression::EQ:  append_to_buffer(" == ");  break;
-      case Binary_Expression::NEQ: append_to_buffer(" != ");  break;
-      case Binary_Expression::GT:  append_to_buffer(" > ");   break;
-      case Binary_Expression::GTE: append_to_buffer(" >= ");  break;
-      case Binary_Expression::LT:  append_to_buffer(" < ");   break;
-      case Binary_Expression::LTE: append_to_buffer(" <= ");  break;
-      case Binary_Expression::ADD: append_to_buffer(" + ");   break;
-      case Binary_Expression::SUB: append_to_buffer(" - ");   break;
-      case Binary_Expression::MUL: append_to_buffer(" * ");   break;
-      case Binary_Expression::DIV: append_to_buffer("/");     break;
-      case Binary_Expression::MOD: append_to_buffer(" % ");   break;
+      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;
       default: break; // shouldn't get here
     }
     expr->right()->perform(this);
@@ -306,14 +392,14 @@ namespace Sass {
 
   void Inspect::operator()(Unary_Expression* expr)
   {
-    if (expr->type() == Unary_Expression::PLUS) append_to_buffer("+");
-    else                                        append_to_buffer("-");
+    if (expr->type() == Unary_Expression::PLUS) append_string("+");
+    else                                        append_string("-");
     expr->operand()->perform(this);
   }
 
   void Inspect::operator()(Function_Call* call)
   {
-    append_to_buffer(call->name());
+    append_token(call->name(), call);
     call->arguments()->perform(this);
   }
 
@@ -325,34 +411,13 @@ namespace Sass {
 
   void Inspect::operator()(Variable* var)
   {
-    append_to_buffer(var->name());
+    append_token(var->name(), var);
   }
 
   void Inspect::operator()(Textual* txt)
   {
-    append_to_buffer(txt->value());
-  }
-
-  // helper functions for serializing numbers
-  // string frac_to_string(double f, size_t p) {
-  //   stringstream ss;
-  //   ss.setf(ios::fixed, ios::floatfield);
-  //   ss.precision(p);
-  //   ss << f;
-  //   string result(ss.str().substr(f < 0 ? 2 : 1));
-  //   size_t i = result.size() - 1;
-  //   while (result[i] == '0') --i;
-  //   result = result.substr(0, i+1);
-  //   return result;
-  // }
-  // string double_to_string(double d, size_t p) {
-  //   stringstream ss;
-  //   double ipart;
-  //   double fpart = std::modf(d, &ipart);
-  //   ss << ipart;
-  //   if (fpart != 0) ss << frac_to_string(fpart, 5);
-  //   return ss.str();
-  // }
+    append_token(txt->value(), txt);
+  }
 
   void Inspect::operator()(Number* n)
   {
@@ -368,10 +433,14 @@ namespace Sass {
       d.resize(d.length()-1);
     }
     if (d[d.length()-1] == '.') d.resize(d.length()-1);
-    if (n->numerator_units().size() > 1 || n->denominator_units().size() > 0) {
-      error(d + n->unit() + " is not a valid CSS value", n->path(), n->position());
-    }
-    if (!n->zero()) {
+    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(d + n->unit() + " isn't a valid CSS value.", n->pstate());
+    }
+    if (!n->zero() && !in_declaration_list) {
       if (d.substr(0, 3) == "-0.") d.erase(1, 1);
       if (d.substr(0, 2) == "0.") d.erase(0, 1);
     }
@@ -381,8 +450,7 @@ namespace Sass {
     // a value before it got truncated
     if (d == "0" && nonzero) d = "0.0";
     // append number and unit
-    append_to_buffer(d);
-    append_to_buffer(n->unit());
+    append_token(d + n->unit(), n);
   }
 
   // helper function for serializing colors
@@ -396,47 +464,85 @@ namespace Sass {
   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);
+    }
+
     // retain the originally specified color definition if unchanged
-    if (!c->disp().empty()) {
-      ss << c->disp();
+    if (name != "") {
+      ss << name;
     }
     else if (r == 0 && g == 0 && b == 0 && a == 0) {
         ss << "transparent";
     }
     else if (a >= 1) {
-      // see if it's a named color
-      int numval = r * 0x10000;
-      numval += g * 0x100;
-      numval += b;
-      if (ctx && ctx->colors_to_names.count(numval)) {
-        ss << ctx->colors_to_names[numval];
+      if (res_name != "") {
+        if (want_short && hexlet.str().size() < res_name.size()) {
+          ss << hexlet.str();
+        } else {
+          ss << res_name;
+        }
       }
       else {
-        // otherwise output the hex triplet
-        ss << '#' << setw(2) << setfill('0');
-        ss << hex << setw(2) << static_cast<unsigned long>(r);
-        ss << hex << setw(2) << static_cast<unsigned long>(g);
-        ss << hex << setw(2) << static_cast<unsigned long>(b);
+        ss << hexlet.str();
       }
     }
     else {
       ss << "rgba(";
-      ss << static_cast<unsigned long>(r) << ", ";
-      ss << static_cast<unsigned long>(g) << ", ";
-      ss << static_cast<unsigned long>(b) << ", ";
+      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_to_buffer(ss.str());
+    append_token(ss.str(), c);
   }
 
   void Inspect::operator()(Boolean* b)
   {
-    append_to_buffer(b->value() ? "true" : "false");
+    append_token(b->value() ? "true" : "false", b);
   }
 
   void Inspect::operator()(String_Schema* ss)
@@ -444,15 +550,27 @@ namespace Sass {
     // 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_to_buffer("#{");
+      if ((*ss)[i]->is_interpolant()) append_string("#{");
       (*ss)[i]->perform(this);
-      if ((*ss)[i]->is_interpolant()) append_to_buffer("}");
+      if ((*ss)[i]->is_interpolant()) append_string("}");
     }
   }
 
   void Inspect::operator()(String_Constant* s)
   {
-    append_to_buffer(s->needs_unquoting() ? unquote(s->value()) : s->value());
+    if (String_Quoted* quoted = dynamic_cast<String_Quoted*>(s)) {
+      return Inspect::operator()(quoted);
+    }
+    append_token(s->value(), s);
+  }
+
+  void Inspect::operator()(String_Quoted* s)
+  {
+    if (s->quote_mark()) {
+      append_token(quote(s->value(), s->quote_mark()), s);
+    } else {
+      append_token(s->value(), s);
+    }
   }
 
   void Inspect::operator()(Feature_Query* fq)
@@ -466,40 +584,46 @@ namespace Sass {
 
   void Inspect::operator()(Feature_Query_Condition* fqc)
   {
-    if (fqc->operand() == Feature_Query_Condition::AND)
-      append_to_buffer(" and ");
-    else if (fqc->operand() == Feature_Query_Condition::OR)
-      append_to_buffer(" or ");
-    else if (fqc->operand() == Feature_Query_Condition::NOT)
-      append_to_buffer(" not ");
+    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) {
+      append_mandatory_space();
+      append_token("or", fqc);
+      append_mandatory_space();
+    } else if (fqc->operand() == Feature_Query_Condition::NOT) {
+      append_mandatory_space();
+      append_token("not", fqc);
+      append_mandatory_space();
+    }
 
-    if (!fqc->is_root()) append_to_buffer("(");
+    if (!fqc->is_root()) append_string("(");
 
     if (!fqc->length()) {
       fqc->feature()->perform(this);
-      append_to_buffer(": ");
+      append_string(": "); // verified
       fqc->value()->perform(this);
     }
-    // else
     for (size_t i = 0, L = fqc->length(); i < L; ++i)
       (*fqc)[i]->perform(this);
 
-    if (!fqc->is_root()) append_to_buffer(")");
+    if (!fqc->is_root()) append_string(")");
   }
 
   void Inspect::operator()(Media_Query* mq)
   {
     size_t i = 0;
     if (mq->media_type()) {
-      if      (mq->is_negated())    append_to_buffer("not ");
-      else if (mq->is_restricted()) append_to_buffer("only ");
+      if      (mq->is_negated())    append_string("not ");
+      else if (mq->is_restricted()) append_string("only ");
       mq->media_type()->perform(this);
     }
     else {
       (*mq)[i++]->perform(this);
     }
     for (size_t L = mq->length(); i < L; ++i) {
-      append_to_buffer(" and ");
+      append_string(" and ");
       (*mq)[i]->perform(this);
     }
   }
@@ -510,77 +634,96 @@ namespace Sass {
       mqe->feature()->perform(this);
     }
     else {
-      append_to_buffer("(");
+      append_string("(");
       mqe->feature()->perform(this);
       if (mqe->value()) {
-        append_to_buffer(": ");
+        append_string(": "); // verified
         mqe->value()->perform(this);
       }
-      append_to_buffer(")");
+      append_string(")");
+    }
+  }
+
+  void Inspect::operator()(At_Root_Expression* ae)
+  {
+    if (ae->is_interpolated()) {
+      ae->feature()->perform(this);
+    }
+    else {
+      append_string("(");
+      ae->feature()->perform(this);
+      if (ae->value()) {
+        append_colon_separator();
+        ae->value()->perform(this);
+      }
+      append_string(")");
     }
   }
 
   void Inspect::operator()(Null* n)
   {
-    append_to_buffer("null");
+    append_token("null", n);
   }
 
   // parameters and arguments
   void Inspect::operator()(Parameter* p)
   {
-    append_to_buffer(p->name());
+    append_token(p->name(), p);
     if (p->default_value()) {
-      append_to_buffer(": ");
+      append_colon_separator();
       p->default_value()->perform(this);
     }
     else if (p->is_rest_parameter()) {
-      append_to_buffer("...");
+      append_string("...");
     }
   }
 
   void Inspect::operator()(Parameters* p)
   {
-    append_to_buffer("(");
+    append_string("(");
     if (!p->empty()) {
       (*p)[0]->perform(this);
       for (size_t i = 1, L = p->length(); i < L; ++i) {
-        append_to_buffer(", ");
+        append_comma_separator();
         (*p)[i]->perform(this);
       }
     }
-    append_to_buffer(")");
+    append_string(")");
   }
 
   void Inspect::operator()(Argument* a)
   {
     if (!a->name().empty()) {
-      append_to_buffer(a->name());
-      append_to_buffer(": ");
+      append_token(a->name(), a);
+      append_colon_separator();
     }
     // Special case: argument nulls can be ignored
     if (a->value()->concrete_type() == Expression::NULL_VAL) {
       return;
     }
-    a->value()->perform(this);
+    if (a->value()->concrete_type() == Expression::STRING) {
+      String_Constant* s = static_cast<String_Constant*>(a->value());
+      s->perform(this);
+    } else a->value()->perform(this);
     if (a->is_rest_argument()) {
-      append_to_buffer("...");
+      append_string("...");
     }
   }
 
   void Inspect::operator()(Arguments* a)
   {
-    append_to_buffer("(");
+    append_string("(");
     if (!a->empty()) {
       (*a)[0]->perform(this);
       for (size_t i = 1, L = a->length(); i < L; ++i) {
-        append_to_buffer(", ");
+        append_string(", "); // verified
+        // Sass Bug? append_comma_separator();
         (*a)[i]->perform(this);
       }
     }
-    append_to_buffer(")");
+    append_string(")");
   }
 
-  // selectors
   void Inspect::operator()(Selector_Schema* s)
   {
     s->contents()->perform(this);
@@ -589,57 +732,58 @@ namespace Sass {
   void Inspect::operator()(Selector_Reference* ref)
   {
     if (ref->selector()) ref->selector()->perform(this);
-    else                 append_to_buffer("&");
+    else                 append_string("&");
   }
 
   void Inspect::operator()(Selector_Placeholder* s)
   {
-    append_to_buffer(s->name());
+    append_token(s->name(), s);
+    if (s->has_line_break()) append_optional_linefeed();
+    if (s->has_line_break()) append_indentation();
+
   }
 
   void Inspect::operator()(Type_Selector* s)
   {
-    if (ctx) ctx->source_map.add_mapping(s);
-    append_to_buffer(s->name());
+    append_token(s->name(), s);
   }
 
   void Inspect::operator()(Selector_Qualifier* s)
   {
-    if (ctx) ctx->source_map.add_mapping(s);
-    append_to_buffer(s->name());
+    append_token(s->name(), s);
+    if (s->has_line_break()) append_optional_linefeed();
+    if (s->has_line_break()) append_indentation();
   }
 
   void Inspect::operator()(Attribute_Selector* s)
   {
-    if (ctx) ctx->source_map.add_mapping(s);
-    append_to_buffer("[");
-    append_to_buffer(s->name());
+    append_string("[");
+    add_open_mapping(s);
+    append_token(s->name(), s);
     if (!s->matcher().empty()) {
-      append_to_buffer(s->matcher());
+      append_string(s->matcher());
       if (s->value()) {
         s->value()->perform(this);
       }
-      // append_to_buffer(s->value());
     }
-    append_to_buffer("]");
+    add_close_mapping(s);
+    append_string("]");
   }
 
   void Inspect::operator()(Pseudo_Selector* s)
   {
-    if (ctx) ctx->source_map.add_mapping(s);
-    append_to_buffer(s->name());
+    append_token(s->name(), s);
     if (s->expression()) {
       s->expression()->perform(this);
-      append_to_buffer(")");
+      append_string(")");
     }
   }
 
   void Inspect::operator()(Wrapped_Selector* s)
   {
-    if (ctx) ctx->source_map.add_mapping(s);
-    append_to_buffer(s->name());
+    append_token(s->name(), s);
     s->selector()->perform(this);
-    append_to_buffer(")");
+    append_string(")");
   }
 
   void Inspect::operator()(Compound_Selector* s)
@@ -647,6 +791,9 @@ namespace Sass {
     for (size_t i = 0, L = s->length(); i < L; ++i) {
       (*s)[i]->perform(this);
     }
+    if (s->has_line_break()) {
+      append_optional_linefeed();
+    }
   }
 
   void Inspect::operator()(Complex_Selector* c)
@@ -655,15 +802,34 @@ namespace Sass {
     Complex_Selector*            tail = c->tail();
     Complex_Selector::Combinator comb = c->combinator();
     if (head && !head->is_empty_reference()) head->perform(this);
-    if (head && !head->is_empty_reference() && tail) append_to_buffer(" ");
+    bool is_empty = head && 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;
+
     switch (comb) {
-      case Complex_Selector::ANCESTOR_OF:                                        break;
-      case Complex_Selector::PARENT_OF:   append_to_buffer(">"); break;
-      case Complex_Selector::PRECEDES:    append_to_buffer("~"); break;
-      case Complex_Selector::ADJACENT_TO: append_to_buffer("+"); break;
+      case Complex_Selector::ANCESTOR_OF:
+        if (is_tail) append_mandatory_space();
+      break;
+      case Complex_Selector::PARENT_OF:
+        append_optional_space();
+        append_string(">");
+        append_optional_space();
+      break;
+      case Complex_Selector::ADJACENT_TO:
+        append_optional_space();
+        append_string("+");
+        append_optional_space();
+      break;
+      case Complex_Selector::PRECEDES:
+        if (is_empty) append_optional_space();
+        else append_mandatory_space();
+        append_string("~");
+        if (tail) append_mandatory_space();
+        else append_optional_space();
+      break;
     }
     if (tail && comb != Complex_Selector::ANCESTOR_OF) {
-      append_to_buffer(" ");
+      if (c->has_line_break()) append_optional_linefeed();
     }
     if (tail) tail->perform(this);
   }
@@ -671,57 +837,21 @@ namespace Sass {
   void Inspect::operator()(Selector_List* g)
   {
     if (g->empty()) return;
-    (*g)[0]->perform(this);
-    for (size_t i = 1, L = g->length(); i < L; ++i) {
-      append_to_buffer(", ");
+    for (size_t i = 0, L = g->length(); i < L; ++i) {
+      if (!in_at_rule && i == 0) append_indentation();
       (*g)[i]->perform(this);
+      if (i < L - 1) {
+        append_comma_separator();
+        if ((*g)[i]->has_line_feed()) {
+          append_optional_linefeed();
+          append_indentation();
+        }
+      }
     }
   }
 
-  inline void Inspect::fallback_impl(AST_Node* n)
-  { }
-
-  void Inspect::indent()
-  { append_to_buffer(string(2*indentation, ' ')); }
-
-  string unquote(const string& s)
-  {
-    if (s.empty()) return "";
-    if (s.length() == 1) {
-      if (s[0] == '"' || s[0] == '\'') return "";
-    }
-    char q;
-    if      (*s.begin() == '"'  && *s.rbegin() == '"')  q = '"';
-    else if (*s.begin() == '\'' && *s.rbegin() == '\'') q = '\'';
-    else                                                return s;
-    string t;
-    t.reserve(s.length()-2);
-    for (size_t i = 1, L = s.length()-1; i < L; ++i) {
-      // if we see a quote, we need to remove the preceding backslash from t
-      if (s[i-1] == '\\' && s[i] == q) t.erase(t.length()-1);
-      t.push_back(s[i]);
-    }
-    return t;
-  }
-
-  string quote(const string& s, char q)
-  {
-    if (s.empty()) return string(2, q);
-    if (!q || s[0] == '"' || s[0] == '\'') return s;
-    string t;
-    t.reserve(s.length()+2);
-    t.push_back(q);
-    for (size_t i = 0, L = s.length(); i < L; ++i) {
-      if (s[i] == q) t.push_back('\\');
-      t.push_back(s[i]);
-    }
-    t.push_back(q);
-    return t;
-  }
-
-  void Inspect::append_to_buffer(const string& text)
+  void Inspect::fallback_impl(AST_Node* n)
   {
-    buffer += text;
   }
 
 }