sassc4 2.4.0

data/ext/libsass/src/output.cpp

@@ -0,0 +1,320 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast.hpp"
+#include "output.hpp"
+#include "util.hpp"
+
+namespace Sass {
+
+  Output::Output(Sass_Output_Options& opt)
+  : Inspect(Emitter(opt)),
+    charset(""),
+    top_nodes(0)
+  {}
+
+  Output::~Output() { }
+
+  void Output::fallback_impl(AST_Node* n)
+  {
+    return n->perform(this);
+  }
+
+  void Output::operator()(Number* n)
+  {
+    // check for a valid unit here
+    // includes result for reporting
+    if (!n->is_valid_css_unit()) {
+      // should be handle in check_expression
+      throw Exception::InvalidValue({}, *n);
+    }
+    // use values to_string facility
+    sass::string res = n->to_string(opt);
+    // output the final token
+    append_token(res, n);
+  }
+
+  void Output::operator()(Import* imp)
+  {
+    top_nodes.push_back(imp);
+  }
+
+  void Output::operator()(Map* m)
+  {
+    // should be handle in check_expression
+    throw Exception::InvalidValue({}, *m);
+  }
+
+  OutputBuffer Output::get_buffer(void)
+  {
+
+    Emitter emitter(opt);
+    Inspect inspect(emitter);
+
+    size_t size_nodes = top_nodes.size();
+    for (size_t i = 0; i < size_nodes; i++) {
+      top_nodes[i]->perform(&inspect);
+      inspect.append_mandatory_linefeed();
+    }
+
+    // flush scheduled outputs
+    // 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, opt.linefeed)) {
+      // if the output is not completely empty
+      if (!wbuf.buffer.empty()) append_string(opt.linefeed);
+    }
+
+    // search for unicode char
+    for(const char& chr : wbuf.buffer) {
+      // skip all ascii chars
+      // static cast to unsigned to handle `char` being signed / unsigned
+      if (static_cast<unsigned>(chr) < 128) continue;
+      // declare the charset
+      if (output_style() != COMPRESSED)
+        charset = "@charset \"UTF-8\";"
+                + sass::string(opt.linefeed);
+      else charset = "\xEF\xBB\xBF";
+      // abort search
+      break;
+    }
+
+    // add charset as first line, before comments and imports
+    if (!charset.empty()) prepend_string(charset);
+
+    return wbuf;
+
+  }
+
+  void Output::operator()(Comment* c)
+  {
+    // if (indentation && txt == "/**/") return;
+    bool important = c->is_important();
+    if (output_style() != COMPRESSED || important) {
+      if (buffer().size() == 0) {
+        top_nodes.push_back(c);
+      } else {
+        in_comment = true;
+        append_indentation();
+        c->text()->perform(this);
+        in_comment = false;
+        if (indentation == 0) {
+          append_mandatory_linefeed();
+        } else {
+          append_optional_linefeed();
+        }
+      }
+    }
+  }
+
+  void Output::operator()(StyleRule* r)
+  {
+    Block_Obj b = r->block();
+    SelectorListObj s = r->selector();
+
+    if (!s || s->empty()) return;
+
+    // Filter out rulesets that aren't printable (process its children though)
+    if (!Util::isPrintable(r, output_style())) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        const Statement_Obj& stm = b->get(i);
+        if (Cast<ParentStatement>(stm)) {
+          if (!Cast<Declaration>(stm)) {
+            stm->perform(this);
+          }
+        }
+      }
+      return;
+    }
+
+    if (output_style() == NESTED) {
+      indentation += r->tabs();
+    }
+    if (opt.source_comments) {
+      sass::ostream ss;
+      append_indentation();
+      sass::string path(File::abs2rel(r->pstate().getPath()));
+      ss << "/* line " << r->pstate().getLine() << ", " << path << " */";
+      append_string(ss.str());
+      append_optional_linefeed();
+    }
+    scheduled_crutch = s;
+    if (s) s->perform(this);
+    append_scope_opener(b);
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->get(i);
+      bool bPrintExpression = true;
+      // Check print conditions
+      if (Declaration* dec = Cast<Declaration>(stm)) {
+        if (const String_Constant* valConst = Cast<String_Constant>(dec->value())) {
+          const sass::string& val = valConst->value();
+          if (const String_Quoted* qstr = Cast<const String_Quoted>(valConst)) {
+            if (!qstr->quote_mark() && val.empty()) {
+              bPrintExpression = false;
+            }
+          }
+        }
+        else if (List* list = 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->get(list_i);
+            if (!item->is_invisible()) all_invisible = false;
+          }
+          if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
+        }
+      }
+      // Print if OK
+      if (bPrintExpression) {
+        stm->perform(this);
+      }
+    }
+    if (output_style() == NESTED) indentation -= r->tabs();
+    append_scope_closer(b);
+
+  }
+  void Output::operator()(Keyframe_Rule* r)
+  {
+    Block_Obj b = r->block();
+    Selector_Obj v = r->name();
+
+    if (!v.isNull()) {
+      v->perform(this);
+    }
+
+    if (!b) {
+      append_colon_separator();
+      return;
+    }
+
+    append_scope_opener();
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->get(i);
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
+    }
+    append_scope_closer();
+  }
+
+  void Output::operator()(SupportsRule* f)
+  {
+    if (f->is_invisible()) return;
+
+    SupportsConditionObj c = f->condition();
+    Block_Obj b              = f->block();
+
+    // Filter out feature blocks that aren't printable (process its children though)
+    if (!Util::isPrintable(f, output_style())) {
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        Statement_Obj stm = b->get(i);
+        if (Cast<ParentStatement>(stm)) {
+          stm->perform(this);
+        }
+      }
+      return;
+    }
+
+    if (output_style() == NESTED) indentation += f->tabs();
+    append_indentation();
+    append_token("@supports", f);
+    append_mandatory_space();
+    c->perform(this);
+    append_scope_opener();
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->get(i);
+      stm->perform(this);
+      if (i < L - 1) append_special_linefeed();
+    }
+
+    if (output_style() == NESTED) indentation -= f->tabs();
+
+    append_scope_closer();
+
+  }
+
+  void Output::operator()(CssMediaRule* rule)
+  {
+    // Avoid null pointer exception
+    if (rule == nullptr) return;
+    // Skip empty/invisible rule
+    if (rule->isInvisible()) return;
+    // Avoid null pointer exception
+    if (rule->block() == nullptr) return;
+    // Skip empty/invisible rule
+    if (rule->block()->isInvisible()) return;
+    // Skip if block is empty/invisible
+    if (Util::isPrintable(rule, output_style())) {
+      // Let inspect do its magic
+      Inspect::operator()(rule);
+    }
+  }
+
+  void Output::operator()(AtRule* a)
+  {
+    sass::string      kwd   = a->keyword();
+    Selector_Obj   s     = a->selector();
+    ExpressionObj v     = a->value();
+    Block_Obj      b     = a->block();
+
+    append_indentation();
+    append_token(kwd, a);
+    if (s) {
+      append_mandatory_space();
+      in_wrapped = true;
+      s->perform(this);
+      in_wrapped = false;
+    }
+    if (v) {
+      append_mandatory_space();
+      // ruby sass bug? should use options?
+      append_token(v->to_string(/* opt */), v);
+    }
+    if (!b) {
+      append_delimiter();
+      return;
+    }
+
+    if (b->is_invisible() || b->length() == 0) {
+      append_optional_space();
+      return append_string("{}");
+    }
+
+    append_scope_opener();
+
+    bool format = kwd != "@font-face";;
+
+    for (size_t i = 0, L = b->length(); i < L; ++i) {
+      Statement_Obj stm = b->get(i);
+      if (stm) stm->perform(this);
+      if (i < L - 1 && format) append_special_linefeed();
+    }
+
+    append_scope_closer();
+  }
+
+  void Output::operator()(String_Quoted* s)
+  {
+    if (s->quote_mark()) {
+      append_token(quote(s->value(), s->quote_mark()), s);
+    } else if (!in_comment) {
+      append_token(string_to_output(s->value()), s);
+    } else {
+      append_token(s->value(), s);
+    }
+  }
+
+  void Output::operator()(String_Constant* s)
+  {
+    sass::string value(s->value());
+    if (!in_comment && !in_custom_property) {
+      append_token(string_to_output(value), s);
+    } else {
+      append_token(value, s);
+    }
+  }
+
+}

data/ext/libsass/src/output.hpp

@@ -0,0 +1,47 @@
+#ifndef SASS_OUTPUT_H
+#define SASS_OUTPUT_H
+
+#include <string>
+#include <vector>
+
+#include "util.hpp"
+#include "inspect.hpp"
+#include "operation.hpp"
+
+namespace Sass {
+  class Context;
+
+  class Output : public Inspect {
+  protected:
+    using Inspect::operator();
+
+  public:
+    Output(Sass_Output_Options& opt);
+    virtual ~Output();
+
+  protected:
+    sass::string charset;
+    sass::vector<AST_Node*> top_nodes;
+
+  public:
+    OutputBuffer get_buffer(void);
+
+    virtual void operator()(Map*);
+    virtual void operator()(StyleRule*);
+    virtual void operator()(SupportsRule*);
+    virtual void operator()(CssMediaRule*);
+    virtual void operator()(AtRule*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Import*);
+    virtual void operator()(Comment*);
+    virtual void operator()(Number*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(String_Constant*);
+
+    void fallback_impl(AST_Node* n);
+
+  };
+
+}
+
+#endif