sassc 0.0.1

data/ext/libsass/output_compressed.hpp

@@ -0,0 +1,95 @@
+#include <string>
+
+#ifndef SASS_OPERATION
+#include "operation.hpp"
+#endif
+
+namespace Sass {
+  using namespace std;
+
+  struct Context;
+
+  class Output_Compressed : public Operation_CRTP<void, Output_Compressed> {
+    // import all the class-specific methods and override as desired
+    using Operation_CRTP<void, Output_Compressed>::operator();
+
+    string buffer;
+    string rendered_imports;
+    Context* ctx;
+    bool seen_utf8;
+
+    void fallback_impl(AST_Node* n);
+
+    void append_singleline_part_to_buffer(const string& text);
+
+  public:
+    Output_Compressed(Context* ctx = 0);
+    virtual ~Output_Compressed();
+
+    string get_buffer() {
+      return (seen_utf8 ? "@charset \"UTF-8\";\n" : "")
+             + rendered_imports + buffer;
+    }
+
+    // statements
+    virtual void operator()(Block*);
+    virtual void operator()(Ruleset*);
+    // virtual void operator()(Propset*);
+    virtual void operator()(Media_Block*);
+    virtual void operator()(At_Rule*);
+    virtual void operator()(Declaration*);
+    // virtual void operator()(Assignment*);
+    virtual void operator()(Import*);
+    // virtual void operator()(Import_Stub*);
+    // virtual void operator()(Warning*);
+    // virtual void operator()(Error*);
+    // virtual void operator()(Debug*);
+    virtual void operator()(Comment*);
+    // virtual void operator()(If*);
+    // virtual void operator()(For*);
+    // virtual void operator()(Each*);
+    // virtual void operator()(While*);
+    // virtual void operator()(Return*);
+    // virtual void operator()(Extension*);
+    // virtual void operator()(Definition*);
+    // virtual void operator()(Mixin_Call*);
+    // virtual void operator()(Content*);
+    // // expressions
+    virtual void operator()(List*);
+    // virtual void operator()(Binary_Expression*);
+    // virtual void operator()(Unary_Expression*);
+    // virtual void operator()(Function_Call*);
+    // virtual void operator()(Function_Call_Schema*);
+    // virtual void operator()(Variable*);
+    // virtual void operator()(Textual*);
+    // virtual void operator()(Number*);
+    virtual void operator()(Color*);
+    // virtual void operator()(Boolean*);
+    // virtual void operator()(String_Schema*);
+    // virtual void operator()(String_Constant* x);
+    // virtual void operator()(Media_Query*);
+    virtual void operator()(Media_Query_Expression*);
+    virtual void operator()(Null*);
+    // // parameters and arguments
+    // virtual void operator()(Parameter*);
+    // virtual void operator()(Parameters*);
+    virtual void operator()(Argument*);
+    virtual void operator()(Arguments*);
+    // // selectors
+    // virtual void operator()(Selector_Schema*);
+    // virtual void operator()(Selector_Reference*);
+    // virtual void operator()(Selector_Placeholder*);
+    // virtual void operator()(Type_Selector*);
+    // virtual void operator()(Selector_Qualifier*);
+    // virtual void operator()(Attribute_Selector*);
+    // virtual void operator()(Pseudo_Selector*);
+    // virtual void operator()(Wrapped_Selector*);
+    // virtual void operator()(Compound_Selector*);
+    virtual void operator()(Complex_Selector*);
+    virtual void operator()(Selector_List*);
+
+    template <typename U>
+    void fallback(U x) { fallback_impl(x); }
+  };
+
+}

data/ext/libsass/output_nested.cpp

@@ -0,0 +1,364 @@
+#include "output_nested.hpp"
+#include "inspect.hpp"
+#include "ast.hpp"
+#include "context.hpp"
+#include "to_string.hpp"
+#include "util.hpp"
+#include <iostream>
+#include <sstream>
+#include <typeinfo>
+
+namespace Sass {
+  using namespace std;
+
+  Output_Nested::Output_Nested(bool source_comments, Context* ctx)
+  : buffer(""), rendered_imports(""), indentation(0), source_comments(source_comments), ctx(ctx), seen_utf8(false)
+  { }
+  Output_Nested::~Output_Nested() { }
+
+  inline void Output_Nested::fallback_impl(AST_Node* n)
+  {
+    Inspect i(ctx);
+    n->perform(&i);
+    const string& text = i.get_buffer();
+    for(const char& chr : text) {
+      // abort clause
+      if (seen_utf8) break;
+      // skip all normal ascii chars
+      if (Util::isAscii(chr)) continue;
+      // singleton
+      seen_utf8 = true;
+    }
+    buffer += text;
+    if (ctx && !ctx->_skip_source_map_update)
+      ctx->source_map.update_column(text);
+  }
+
+  void Output_Nested::operator()(Import* imp)
+  {
+    Inspect insp(ctx);
+    imp->perform(&insp);
+    if (!rendered_imports.empty()) {
+      rendered_imports += "\n";
+    }
+    rendered_imports += insp.get_buffer();
+  }
+
+  void Output_Nested::operator()(Block* b)
+  {
+    if (!b->is_root()) return;
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      size_t old_len = buffer.length();
+      (*b)[i]->perform(this);
+      if (i < L-1 && old_len < buffer.length()) append_to_buffer("\n");
+    }
+  }
+
+  void Output_Nested::operator()(Ruleset* r)
+  {
+    Selector* s     = r->selector();
+    Block*    b     = r->block();
+    bool      decls = false;
+
+    // disabled to avoid clang warning [-Wunused-function]
+    // Selector_List* sl = static_cast<Selector_List*>(s);
+
+    // Filter out rulesets that aren't printable (process its children though)
+    if (!Util::isPrintable(r)) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (dynamic_cast<Has_Block*>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    if (b->has_non_hoistable()) {
+      decls = true;
+      indent();
+      if (source_comments) {
+        stringstream ss;
+        ss << "/* line " << r->position().line << ", " << r->path() << " */" << endl;
+        append_to_buffer(ss.str());
+        indent();
+      }
+      s->perform(this);
+      append_to_buffer(" {\n");
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        bool bPrintExpression = true;
+        // Check print conditions
+        if (typeid(*stm) == typeid(Declaration)) {
+          Declaration* dec = static_cast<Declaration*>(stm);
+          if (dec->value()->concrete_type() == Expression::STRING) {
+            String_Constant* valConst = static_cast<String_Constant*>(dec->value());
+            string val(valConst->value());
+            if (val.empty()) {
+              bPrintExpression = false;
+            }
+          }
+          else if (dec->value()->concrete_type() == Expression::LIST) {
+            List* list = static_cast<List*>(dec->value());
+            bool all_invisible = true;
+            for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
+              Expression* item = (*list)[list_i];
+              if (!item->is_invisible()) all_invisible = false;
+            }
+            if (all_invisible) bPrintExpression = false;
+          }
+        }
+        // Print if OK
+        if (!stm->is_hoistable() && bPrintExpression) {
+          if (!stm->block()) indent();
+          stm->perform(this);
+          append_to_buffer("\n");
+        }
+      }
+      --indentation;
+      buffer.erase(buffer.length()-1);
+      if (ctx) ctx->source_map.remove_line();
+      append_to_buffer(" }\n");
+    }
+
+    if (b->has_hoistable()) {
+      if (decls) ++indentation;
+      // indent();
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+      if (decls) --indentation;
+    }
+  }
+
+  void Output_Nested::operator()(Feature_Block* f)
+  {
+    Feature_Query* q    = f->feature_queries();
+    Block* b            = f->block();
+
+    // Filter out feature blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(f)) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (dynamic_cast<Has_Block*>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    indent();
+    ctx->source_map.add_mapping(f);
+    append_to_buffer("@supports ");
+    q->perform(this);
+    append_to_buffer(" {\n");
+
+    Selector* e = f->selector();
+    if (e && b->has_non_hoistable()) {
+      // JMA - hoisted, output the non-hoistable in a nested block, followed by the hoistable
+      ++indentation;
+      indent();
+      e->perform(this);
+      append_to_buffer(" {\n");
+
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          if (!stm->block()) indent();
+          stm->perform(this);
+          append_to_buffer("\n");
+        }
+      }
+      --indentation;
+
+      buffer.erase(buffer.length()-1);
+      if (ctx) ctx->source_map.remove_line();
+      append_to_buffer(" }\n");
+      --indentation;
+
+      ++indentation;
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+      --indentation;
+      --indentation;
+    }
+    else {
+      // JMA - not hoisted, just output in order
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          if (!stm->block()) indent();
+        }
+        stm->perform(this);
+        if (!stm->is_hoistable()) append_to_buffer("\n");
+      }
+      --indentation;
+    }
+
+    buffer.erase(buffer.length()-1);
+    if (ctx) ctx->source_map.remove_line();
+    append_to_buffer(" }\n");
+  }
+
+  void Output_Nested::operator()(Media_Block* m)
+  {
+    List*  q     = m->media_queries();
+    Block* b     = m->block();
+
+    // Filter out media blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(m)) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (dynamic_cast<Has_Block*>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    indent();
+    ctx->source_map.add_mapping(m);
+    append_to_buffer("@media ");
+    q->perform(this);
+    append_to_buffer(" {\n");
+
+    Selector* e = m->selector();
+    if (e && b->has_non_hoistable()) {
+      // JMA - hoisted, output the non-hoistable in a nested block, followed by the hoistable
+      ++indentation;
+      indent();
+      e->perform(this);
+      append_to_buffer(" {\n");
+
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          if (!stm->block()) indent();
+          stm->perform(this);
+          append_to_buffer("\n");
+        }
+      }
+      --indentation;
+
+      buffer.erase(buffer.length()-1);
+      if (ctx) ctx->source_map.remove_line();
+      append_to_buffer(" }\n");
+      --indentation;
+
+      ++indentation;
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (stm->is_hoistable()) {
+          stm->perform(this);
+        }
+      }
+      --indentation;
+      --indentation;
+    }
+    else {
+      // JMA - not hoisted, just output in order
+      ++indentation;
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement* stm = (*b)[i];
+        if (!stm->is_hoistable()) {
+          if (!stm->block()) indent();
+        }
+        stm->perform(this);
+        if (!stm->is_hoistable()) append_to_buffer("\n");
+      }
+      --indentation;
+    }
+
+    buffer.erase(buffer.length()-1);
+    if (ctx) ctx->source_map.remove_line();
+    append_to_buffer(" }\n");
+  }
+
+  void Output_Nested::operator()(At_Rule* a)
+  {
+    string      kwd   = a->keyword();
+    Selector*   s     = a->selector();
+    Expression* v     = a->value();
+    Block*      b     = a->block();
+    bool        decls = false;
+
+    // indent();
+    append_to_buffer(kwd);
+    if (s) {
+      append_to_buffer(" ");
+      s->perform(this);
+    }
+    else if (v) {
+      append_to_buffer(" ");
+      v->perform(this);
+    }
+
+    if (!b) {
+      append_to_buffer(";");
+      return;
+    }
+
+    append_to_buffer(" {\n");
+    ++indentation;
+    decls = true;
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      if (!stm->is_hoistable()) {
+        if (!stm->block()) indent();
+        stm->perform(this);
+        append_to_buffer("\n");
+      }
+    }
+    --indentation;
+
+    if (decls) ++indentation;
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement* stm = (*b)[i];
+      if (stm->is_hoistable()) {
+        stm->perform(this);
+        append_to_buffer("\n");
+      }
+    }
+    if (decls) --indentation;
+
+    buffer.erase(buffer.length()-1);
+    if (ctx) ctx->source_map.remove_line();
+    if (b->has_hoistable()) {
+      buffer.erase(buffer.length()-1);
+      if (ctx) ctx->source_map.remove_line();
+    }
+    append_to_buffer(" }\n");
+  }
+
+  void Output_Nested::indent()
+  { append_to_buffer(string(2*indentation, ' ')); }
+
+  void Output_Nested::append_to_buffer(const string& text)
+  {
+    buffer += text;
+    if (ctx && !ctx->_skip_source_map_update)
+      ctx->source_map.update_column(text);
+    for(const char& chr : text) {
+      // abort clause
+      if (seen_utf8) break;
+      // skip all normal ascii chars
+      if (Util::isAscii(chr)) continue;
+      // singleton
+      seen_utf8 = true;
+    }
+  }
+
+}