#include "sass.hpp"
#include "ast.hpp"
#include "output.hpp"
namespace Sass {
Output::Output(Sass_Output_Options& opt)
: Inspect(Emitter(opt)),
charset(""),
top_nodes(0)
{}
Output::~Output() { }
void Output::fallback_impl(AST_Node_Ptr n)
{
return n->perform(this);
}
void Output::operator()(Number_Ptr n)
{
// use values to_string facility
std::string res = n->to_string(opt);
// check for a valid unit here
// includes result for reporting
if (!n->is_valid_css_unit()) {
throw Exception::InvalidValue(*n);
}
// output the final token
append_token(res, n);
}
void Output::operator()(Import_Ptr imp)
{
top_nodes.push_back(imp);
}
void Output::operator()(Map_Ptr m)
{
std::string dbg(m->to_string(opt));
error(dbg + " isn't a valid CSS value.", m->pstate());
}
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\";"
+ std::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_Ptr c)
{
std::string txt = c->text()->to_string(opt);
// 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()(Ruleset_Ptr r)
{
Selector_Obj s = r->selector();
Block_Obj b = r->block();
// 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->at(i);
if (Cast<Has_Block>(stm)) {
if (!Cast<Declaration>(stm)) {
stm->perform(this);
}
}
}
return;
}
if (output_style() == NESTED) indentation += r->tabs();
if (opt.source_comments) {
std::stringstream ss;
append_indentation();
std::string path(File::abs2rel(r->pstate().path));
ss << "/* line " << r->pstate().line + 1 << ", " << path << " */";
append_string(ss.str());
append_optional_linefeed();
}
if (s) s->perform(this);
append_scope_opener(b);
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement_Obj stm = b->at(i);
bool bPrintExpression = true;
// Check print conditions
if (Declaration_Ptr dec = Cast<Declaration>(stm)) {
if (String_Constant_Ptr valConst = Cast<String_Constant>(dec->value())) {
std::string val(valConst->value());
if (String_Quoted_Ptr qstr = Cast<String_Quoted>(valConst)) {
if (!qstr->quote_mark() && val.empty()) {
bPrintExpression = false;
}
}
}
else if (List_Ptr 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_Ptr item = list->at(list_i);
if (!item->is_invisible()) all_invisible = false;
}
if (all_invisible) 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_Ptr 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->at(i);
stm->perform(this);
if (i < L - 1) append_special_linefeed();
}
append_scope_closer();
}
void Output::operator()(Supports_Block_Ptr f)
{
if (f->is_invisible()) return;
Supports_Condition_Obj 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->at(i);
if (Cast<Has_Block>(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->at(i);
stm->perform(this);
if (i < L - 1) append_special_linefeed();
}
if (output_style() == NESTED) indentation -= f->tabs();
append_scope_closer();
}
void Output::operator()(Media_Block_Ptr m)
{
if (m->is_invisible()) return;
Block_Obj b = m->block();
// Filter out media blocks that aren't printable (process its children though)
if (!Util::isPrintable(m, output_style())) {
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement_Obj stm = b->at(i);
if (Cast<Has_Block>(stm)) {
stm->perform(this);
}
}
return;
}
if (output_style() == NESTED) indentation += m->tabs();
append_indentation();
append_token("@media", m);
append_mandatory_space();
in_media_block = true;
m->media_queries()->perform(this);
in_media_block = false;
append_scope_opener();
for (size_t i = 0, L = b->length(); i < L; ++i) {
if (b->at(i)) {
Statement_Obj stm = b->at(i);
stm->perform(this);
}
if (i < L - 1) append_special_linefeed();
}
if (output_style() == NESTED) indentation -= m->tabs();
append_scope_closer();
}
void Output::operator()(Directive_Ptr a)
{
std::string kwd = a->keyword();
Selector_Obj s = a->selector();
Expression_Obj 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->at(i);
stm->perform(this);
if (i < L - 1 && format) append_special_linefeed();
}
append_scope_closer();
}
void Output::operator()(String_Quoted_Ptr 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_Ptr s)
{
std::string value(s->value());
if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
}
if (!in_comment) {
append_token(string_to_output(value), s);
} else {
append_token(value, s);
}
}
}