sassc 1.8.3 → 1.8.4

data/ext/libsass/src/inspect.hpp

@@ -64,6 +64,8 @@ namespace Sass {
     virtual void operator()(String_Schema*);
     virtual void operator()(String_Constant*);
     virtual void operator()(String_Quoted*);
+    virtual void operator()(Custom_Error*);
+    virtual void operator()(Custom_Warning*);
     virtual void operator()(Supports_Operator*);
     virtual void operator()(Supports_Negation*);
     virtual void operator()(Supports_Declaration*);

data/ext/libsass/src/lexer.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cctype>
 #include <cstddef>
 #include <iostream>

data/ext/libsass/src/listize.cpp

@@ -1,43 +1,43 @@
+#include "sass.hpp"
 #include <iostream>
 #include <typeinfo>
 #include <string>
 
 #include "listize.hpp"
-#include "to_string.hpp"
 #include "context.hpp"
 #include "backtrace.hpp"
 #include "error_handling.hpp"
 
 namespace Sass {
 
-  Listize::Listize(Context& ctx)
-  : ctx(ctx)
+  Listize::Listize(Memory_Manager& mem)
+  : mem(mem)
   {  }
 
   Expression* Listize::operator()(Selector_List* sel)
   {
-    List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
+    List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), sel->length(), SASS_COMMA);
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
       if (!(*sel)[i]) continue;
       *l << (*sel)[i]->perform(this);
     }
-    return l;
+    if (l->length()) return l;
+    return SASS_MEMORY_NEW(mem, Null, l->pstate());
   }
 
   Expression* Listize::operator()(Compound_Selector* sel)
   {
-    To_String to_string;
     std::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
       Expression* e = (*sel)[i]->perform(this);
-      if (e) str += e->perform(&to_string);
+      if (e) str += e->to_string();
     }
-    return SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), str);
+    return SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), str);
   }
 
   Expression* Listize::operator()(Complex_Selector* sel)
   {
-    List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), 2);
+    List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), 2);
 
     Compound_Selector* head = sel->head();
     if (head && !head->is_empty_reference())
@@ -46,22 +46,21 @@ namespace Sass {
       if (hh) *l << hh;
     }
 
-    To_String to_string;
     std::string reference = ! sel->reference() ? ""
-      : sel->reference()->perform(&to_string);
+      : sel->reference()->to_string();
     switch(sel->combinator())
     {
       case Complex_Selector::PARENT_OF:
-        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), ">");
+        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), ">");
       break;
       case Complex_Selector::ADJACENT_TO:
-        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "+");
+        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "+");
       break;
       case Complex_Selector::REFERENCE:
-        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "/" + reference + "/");
+        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "/" + reference + "/");
       break;
       case Complex_Selector::PRECEDES:
-        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, sel->pstate(), "~");
+        *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "~");
       break;
       case Complex_Selector::ANCESTOR_OF:
       break;

data/ext/libsass/src/listize.hpp

@@ -16,15 +16,13 @@ namespace Sass {
 
   class Listize : public Operation_CRTP<Expression*, Listize> {
 
-    Context&            ctx;
+    Memory_Manager& mem;
 
     Expression* fallback_impl(AST_Node* n);
 
   public:
-    Listize(Context&);
-    virtual ~Listize() { }
-
-    using Operation<Expression*>::operator();
+    Listize(Memory_Manager&);
+    ~Listize() { }
 
     Expression* operator()(Selector_List*);
     Expression* operator()(Complex_Selector*);

data/ext/libsass/src/memory_manager.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "ast.hpp"
 #include "memory_manager.hpp"
 

data/ext/libsass/src/node.cpp

@@ -1,7 +1,7 @@
+#include "sass.hpp"
 #include <vector>
 
 #include "node.hpp"
-#include "to_string.hpp"
 #include "context.hpp"
 #include "parser.hpp"
 
@@ -153,8 +153,7 @@ namespace Sass {
 
     } else if (node.isSelector()){
 
-      To_String to_string;
-      os << node.selector()->head()->perform(&to_string);
+      os << node.selector()->head()->to_string();
 
     } else if (node.isCollection()) {
 

data/ext/libsass/src/operation.hpp

@@ -15,7 +15,7 @@ namespace Sass {
     virtual T operator()(Ruleset* x)                = 0;
     virtual T operator()(Propset* x)                = 0;
     virtual T operator()(Bubble* x)                 = 0;
-    virtual T operator()(Supports_Block* x)          = 0;
+    virtual T operator()(Supports_Block* x)         = 0;
     virtual T operator()(Media_Block* x)            = 0;
     virtual T operator()(At_Root_Block* x)          = 0;
     virtual T operator()(At_Rule* x)                = 0;
@@ -88,84 +88,83 @@ namespace Sass {
   template <typename T, typename D>
   class Operation_CRTP : public Operation<T> {
   public:
-    virtual T operator()(AST_Node* x)               { return static_cast<D*>(this)->fallback(x); }
-    virtual ~Operation_CRTP()                       = 0;
+    D& impl() { return static_cast<D&>(*this); }
+  public:
+    T operator()(AST_Node* x)               { return static_cast<D*>(this)->fallback(x); }
     // statements
-    virtual T operator()(Block* x)                  { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Propset* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Block* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(At_Rule* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Keyframe_Rule* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Import* x)                 { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Import_Stub* x)            { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Warning* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Error* x)                  { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Debug* x)                  { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Comment* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(If* x)                     { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(For* x)                    { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Each* x)                   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(While* x)                  { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Return* x)                 { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Content* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Extension* x)              { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Definition* x)             { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Mixin_Call* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Block* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Ruleset* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Propset* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Bubble* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Block* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Block* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Block* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Rule* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Keyframe_Rule* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Declaration* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Assignment* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Import* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Import_Stub* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Warning* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Error* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Debug* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Comment* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(If* x)                     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(For* x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Each* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(While* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Return* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Content* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Extension* x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Definition* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Mixin_Call* x)             { return static_cast<D*>(this)->fallback(x); }
     // expressions
-    virtual T operator()(List* x)                   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Map* x)                    { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Binary_Expression* x)      { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Custom_Warning* x)         { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Custom_Error* x)           { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Color* x)                  { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Boolean* x)                { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(At_Root_Expression* x)     { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(List* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Map* x)                    { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Binary_Expression* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Unary_Expression* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Function_Call* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Function_Call_Schema* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Custom_Warning* x)         { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Custom_Error* x)           { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Variable* x)               { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Textual* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Number* x)                 { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Color* x)                  { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Boolean* x)                { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Schema* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Constant* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(String_Quoted* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Condition* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Operator* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Negation* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Declaration* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Supports_Interpolation* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Query* x)            { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Media_Query_Expression* x) { return static_cast<D*>(this)->fallback(x); }
+    T operator()(At_Root_Expression* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Null* x)                   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parent_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
     // parameters and arguments
-    virtual T operator()(Parameter* x)              { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Parameters* x)             { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Argument* x)               { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parameter* x)              { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Parameters* x)             { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Argument* x)               { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Arguments* x)              { return static_cast<D*>(this)->fallback(x); }
     // selectors
-    virtual T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Selector_Placeholder* x)   { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Type_Selector* x)          { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Selector_Qualifier* x)     { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Pseudo_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Wrapped_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Compound_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Complex_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
-    virtual T operator()(Selector_List* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Selector_Schema* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Selector_Placeholder* x)   { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Type_Selector* x)          { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Selector_Qualifier* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Pseudo_Selector* x)        { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Wrapped_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Compound_Selector* x)      { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Complex_Selector* x)       { return static_cast<D*>(this)->fallback(x); }
+    T operator()(Selector_List* x)          { return static_cast<D*>(this)->fallback(x); }
 
     template <typename U>
     T fallback(U x)                                 { return T(); }
   };
-  template<typename T, typename D>
-  inline Operation_CRTP<T, D>::~Operation_CRTP()    { }
 
 }
 

data/ext/libsass/src/output.cpp

@@ -1,11 +1,11 @@
+#include "sass.hpp"
 #include "ast.hpp"
 #include "output.hpp"
-#include "to_string.hpp"
 
 namespace Sass {
 
-  Output::Output(Context* ctx)
-  : Inspect(Emitter(ctx)),
+  Output::Output(Sass_Output_Options& opt)
+  : Inspect(Emitter(opt)),
     charset(""),
     top_nodes(0)
   {}
@@ -20,16 +20,11 @@ namespace Sass {
   void Output::operator()(Number* n)
   {
     // use values to_string facility
-    To_String to_string(ctx);
-    std::string res = n->perform(&to_string);
+    std::string res = n->to_string(opt);
     // 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('/') != std::string::npos) ||
-        (n->numerator_units().size() && n->numerator_units()[0].find_first_of('*') != std::string::npos)
-    ) {
-      error(res + " isn't a valid CSS value.", n->pstate());
+    if (!n->is_valid_css_unit()) {
+      throw Exception::InvalidValue(*n);
     }
     // output the final token
     append_token(res, n);
@@ -42,15 +37,14 @@ namespace Sass {
 
   void Output::operator()(Map* m)
   {
-    To_String to_string(ctx);
-    std::string dbg(m->perform(&to_string));
+    std::string dbg(m->to_string(opt));
     error(dbg + " isn't a valid CSS value.", m->pstate());
   }
 
   OutputBuffer Output::get_buffer(void)
   {
 
-    Emitter emitter(ctx);
+    Emitter emitter(opt);
     Inspect inspect(emitter);
 
     size_t size_nodes = top_nodes.size();
@@ -60,13 +54,14 @@ namespace Sass {
     }
 
     // flush scheduled outputs
-    inspect.finalize();
+    // maybe omit semicolon if possible
+    inspect.finalize(wbuf.buffer.size() == 0);
     // prepend buffer on top
     prepend_output(inspect.output());
     // make sure we end with a linefeed
-    if (!ends_with(wbuf.buffer, ctx->linefeed)) {
+    if (!ends_with(wbuf.buffer, opt.linefeed)) {
       // if the output is not completely empty
-      if (!wbuf.buffer.empty()) append_string(ctx->linefeed);
+      if (!wbuf.buffer.empty()) append_string(opt.linefeed);
     }
 
     // search for unicode char
@@ -74,9 +69,9 @@ namespace Sass {
       // skip all ascii chars
       if (chr >= 0) continue;
       // declare the charset
-      if (output_style() != SASS_STYLE_COMPRESSED)
+      if (output_style() != COMPRESSED)
         charset = "@charset \"UTF-8\";"
-                  + ctx->linefeed;
+                + std::string(opt.linefeed);
       else charset = "\xEF\xBB\xBF";
       // abort search
       break;
@@ -91,11 +86,10 @@ namespace Sass {
 
   void Output::operator()(Comment* c)
   {
-    To_String to_string(ctx);
-    std::string txt = c->text()->perform(&to_string);
+    std::string txt = c->text()->to_string(opt);
     // if (indentation && txt == "/**/") return;
     bool important = c->is_important();
-    if (output_style() != SASS_STYLE_COMPRESSED || important) {
+    if (output_style() != COMPRESSED || important) {
       if (buffer().size() == 0) {
         top_nodes.push_back(c);
       } else {
@@ -131,8 +125,8 @@ namespace Sass {
 
     if (b->has_non_hoistable()) {
       decls = true;
-      if (output_style() == SASS_STYLE_NESTED) indentation += r->tabs();
-      if (ctx && ctx->c_options->source_comments) {
+      if (output_style() == NESTED) indentation += r->tabs();
+      if (opt.source_comments) {
         std::stringstream ss;
         append_indentation();
         ss << "/* line " << r->pstate().line + 1 << ", " << r->pstate().path << " */";
@@ -171,7 +165,7 @@ namespace Sass {
           stm->perform(this);
         }
       }
-      if (output_style() == SASS_STYLE_NESTED) indentation -= r->tabs();
+      if (output_style() == NESTED) indentation -= r->tabs();
       append_scope_closer(b);
     }
 
@@ -238,7 +232,7 @@ namespace Sass {
       return;
     }
 
-    if (output_style() == SASS_STYLE_NESTED) indentation += f->tabs();
+    if (output_style() == NESTED) indentation += f->tabs();
     append_indentation();
     append_token("@supports", f);
     append_mandatory_space();
@@ -274,7 +268,7 @@ namespace Sass {
       }
     }
 
-    if (output_style() == SASS_STYLE_NESTED) indentation -= f->tabs();
+    if (output_style() == NESTED) indentation -= f->tabs();
 
     append_scope_closer();
 
@@ -297,7 +291,7 @@ namespace Sass {
       }
       return;
     }
-    if (output_style() == SASS_STYLE_NESTED) indentation += m->tabs();
+    if (output_style() == NESTED) indentation += m->tabs();
     append_indentation();
     append_token("@media", m);
     append_mandatory_space();
@@ -311,7 +305,7 @@ namespace Sass {
       if (i < L - 1) append_special_linefeed();
     }
 
-    if (output_style() == SASS_STYLE_NESTED) indentation -= m->tabs();
+    if (output_style() == NESTED) indentation -= m->tabs();
     append_scope_closer();
   }
 
@@ -332,7 +326,8 @@ namespace Sass {
     }
     if (v) {
       append_mandatory_space();
-      v->perform(this);
+      // ruby sass bug? should use options?
+      append_token(v->to_string(/* opt */), v);
     }
     if (!b) {
       append_delimiter();
@@ -340,7 +335,8 @@ namespace Sass {
     }
 
     if (b->is_invisible() || b->length() == 0) {
-      return append_string(" {}");
+      append_optional_space();
+      return append_string("{}");
     }
 
     append_scope_opener();
@@ -380,7 +376,7 @@ namespace Sass {
   void Output::operator()(String_Constant* s)
   {
     std::string value(s->value());
-    if (s->can_compress_whitespace() && output_style() == SASS_STYLE_COMPRESSED) {
+    if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
       value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
     }
     if (!in_comment) {