sassc 1.11.4 → 1.12.0

data/ext/libsass/src/emitter.cpp

@@ -14,7 +14,9 @@ namespace Sass {
     scheduled_space(0),
     scheduled_linefeed(0),
     scheduled_delimiter(false),
+    scheduled_crutch(0),
     scheduled_mapping(0),
+    in_custom_property(false),
     in_comment(false),
     in_wrapped(false),
     in_media_block(false),
@@ -101,10 +103,30 @@ namespace Sass {
   // prepend some text or token to the buffer
   void Emitter::prepend_string(const std::string& text)
   {
-    wbuf.smap.prepend(Offset(text));
+    // do not adjust mappings for utf8 bom
+    // seems they are not counted in any UA
+    if (text.compare("\xEF\xBB\xBF") != 0) {
+      wbuf.smap.prepend(Offset(text));
+    }
     wbuf.buffer = text + wbuf.buffer;
   }
 
+  char Emitter::last_char()
+  {
+    return wbuf.buffer.back();
+  }
+
+  // append a single char to the buffer
+  void Emitter::append_char(const char chr)
+  {
+    // write space/lf
+    flush_schedules();
+    // add to buffer
+    wbuf.buffer += chr;
+    // account for data in source-maps
+    wbuf.smap.append(Offset(chr));
+  }
+
   // append some text or token to the buffer
   void Emitter::append_string(const std::string& text)
   {
@@ -145,9 +167,9 @@ namespace Sass {
     add_open_mapping(node);
     // hotfix for browser issues
     // this is pretty ugly indeed
-    if (scheduled_mapping) {
-      add_open_mapping(scheduled_mapping);
-      scheduled_mapping = 0;
+    if (scheduled_crutch) {
+      add_open_mapping(scheduled_crutch);
+      scheduled_crutch = 0;
     }
     append_string(text);
     add_close_mapping(node);
@@ -193,7 +215,7 @@ namespace Sass {
   {
     scheduled_space = 0;
     append_string(":");
-    append_optional_space();
+    if (!in_custom_property) append_optional_space();
   }
 
   void Emitter::append_mandatory_space()
@@ -206,7 +228,9 @@ namespace Sass {
     if ((output_style() != COMPRESSED) && buffer().size()) {
       unsigned char lst = buffer().at(buffer().length() - 1);
       if (!isspace(lst) || scheduled_delimiter) {
-        append_mandatory_space();
+        if (last_char() != '(') {
+          append_mandatory_space();
+        }
       }
     }
   }

data/ext/libsass/src/emitter.hpp

@@ -37,9 +37,12 @@ namespace Sass {
       size_t scheduled_space;
       size_t scheduled_linefeed;
       bool scheduled_delimiter;
+      AST_Node_Ptr scheduled_crutch;
       AST_Node_Ptr scheduled_mapping;
 
     public:
+      // output strings different in custom css properties
+      bool in_custom_property;
       // output strings different in comments
       bool in_comment;
       // selector list does not get linefeeds
@@ -66,11 +69,15 @@ namespace Sass {
       void prepend_output(const OutputBuffer& out);
       // append some text or token to the buffer
       void append_string(const std::string& text);
+      // append a single character to buffer
+      void append_char(const char chr);
       // append some white-space only text
       void append_wspace(const std::string& text);
       // append some text or token to the buffer
       // this adds source-mappings for node start and end
       void append_token(const std::string& text, const AST_Node_Ptr node);
+      // query last appended character
+      char last_char();
 
     public: // syntax sugar
       void append_indentation();

data/ext/libsass/src/environment.cpp

@@ -6,17 +6,17 @@ namespace Sass {
 
   template <typename T>
   Environment<T>::Environment(bool is_shadow)
-  : local_frame_(std::map<std::string, T>()),
+  : local_frame_(environment_map<std::string, T>()),
     parent_(0), is_shadow_(false)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>* env, bool is_shadow)
-  : local_frame_(std::map<std::string, T>()),
+  : local_frame_(environment_map<std::string, T>()),
     parent_(env), is_shadow_(is_shadow)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>& env, bool is_shadow)
-  : local_frame_(std::map<std::string, T>()),
+  : local_frame_(environment_map<std::string, T>()),
     parent_(&env), is_shadow_(is_shadow)
   { }
 
@@ -45,7 +45,7 @@ namespace Sass {
   }
 
   template <typename T>
-  std::map<std::string, T>& Environment<T>::local_frame() {
+  environment_map<std::string, T>& Environment<T>::local_frame() {
     return local_frame_;
   }
 
@@ -53,12 +53,25 @@ namespace Sass {
   bool Environment<T>::has_local(const std::string& key) const
   { return local_frame_.find(key) != local_frame_.end(); }
 
+  template <typename T> EnvResult
+  Environment<T>::find_local(const std::string& key)
+  {
+    auto end = local_frame_.end();
+    auto it = local_frame_.find(key);
+    return EnvResult(it, it != end);
+  }
+
   template <typename T>
   T& Environment<T>::get_local(const std::string& key)
   { return local_frame_[key]; }
 
   template <typename T>
-  void Environment<T>::set_local(const std::string& key, T val)
+  void Environment<T>::set_local(const std::string& key, const T& val)
+  {
+    local_frame_[key] = val;
+  }
+  template <typename T>
+  void Environment<T>::set_local(const std::string& key, T&& val)
   {
     local_frame_[key] = val;
   }
@@ -86,7 +99,12 @@ namespace Sass {
   { return (*global_env())[key]; }
 
   template <typename T>
-  void Environment<T>::set_global(const std::string& key, T val)
+  void Environment<T>::set_global(const std::string& key, const T& val)
+  {
+    global_env()->local_frame_[key] = val;
+  }
+  template <typename T>
+  void Environment<T>::set_global(const std::string& key, T&& val)
   {
     global_env()->local_frame_[key] = val;
   }
@@ -126,12 +144,31 @@ namespace Sass {
   // either update already existing lexical value
   // or if flag is set, we create one if no lexical found
   template <typename T>
-  void Environment<T>::set_lexical(const std::string& key, T val)
+  void Environment<T>::set_lexical(const std::string& key, const T& val)
   {
-    auto cur = this; bool shadow = false;
-    while (cur->is_lexical() || shadow) {
-      if (cur->has_local(key)) {
-        cur->set_local(key, val);
+    Environment<T>* cur = this;
+    bool shadow = false;
+    while ((cur && cur->is_lexical()) || shadow) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) {
+        rv.it->second = val;
+        return;
+      }
+      shadow = cur->is_shadow();
+      cur = cur->parent_;
+    }
+    set_local(key, val);
+  }
+  // this one moves the value
+  template <typename T>
+  void Environment<T>::set_lexical(const std::string& key, T&& val)
+  {
+    Environment<T>* cur = this;
+    bool shadow = false;
+    while ((cur && cur->is_lexical()) || shadow) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) {
+        rv.it->second = val;
         return;
       }
       shadow = cur->is_shadow();
@@ -155,6 +192,20 @@ namespace Sass {
     return false;
   }
 
+  // look on the full stack for key
+  // include all scopes available
+  template <typename T> EnvResult
+  Environment<T>::find(const std::string& key)
+  {
+    auto cur = this;
+    while (true) {
+      EnvResult rv(cur->find_local(key));
+      if (rv.found) return rv;
+      cur = cur->parent_;
+      if (!cur) return rv;
+    }
+  };
+
   // use array access for getter and setter functions
   template <typename T>
   T& Environment<T>::operator[](const std::string& key)
@@ -168,7 +219,7 @@ namespace Sass {
     }
     return get_local(key);
   }
-
+/*
   #ifdef DEBUG
   template <typename T>
   size_t Environment<T>::print(std::string prefix)
@@ -176,10 +227,10 @@ namespace Sass {
     size_t indent = 0;
     if (parent_) indent = parent_->print(prefix) + 1;
     std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
-    for (typename std::map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
+    for (typename environment_map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
-        std::cerr << prefix << std::string(indent, ' ') << i->first << " "  << i->second;
-        if (Value_Ptr val = SASS_MEMORY_CAST_PTR(Value, i->second))
+        std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
+        if (Value_Ptr val = Cast<Value>(i->second))
         { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;
       }
@@ -187,7 +238,7 @@ namespace Sass {
     return indent ;
   }
   #endif
-
+*/
   // compile implementation for AST_Node
   template class Environment<AST_Node_Obj>;
 

data/ext/libsass/src/environment.hpp

@@ -2,17 +2,26 @@
 #define SASS_ENVIRONMENT_H
 
 #include <string>
-#include <map>
-
 #include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"
 
 namespace Sass {
 
+  typedef environment_map<std::string, AST_Node_Obj>::iterator EnvIter;
+
+  class EnvResult {
+    public:
+      EnvIter it;
+      bool found;
+    public:
+      EnvResult(EnvIter it, bool found)
+      : it(it), found(found) {}
+  };
+
   template <typename T>
   class Environment {
     // TODO: test with map
-    std::map<std::string, T> local_frame_;
+    environment_map<std::string, T> local_frame_;
     ADD_PROPERTY(Environment*, parent)
     ADD_PROPERTY(bool, is_shadow)
 
@@ -37,14 +46,17 @@ namespace Sass {
 
     // scope operates on the current frame
 
-    std::map<std::string, T>& local_frame();
+    environment_map<std::string, T>& local_frame();
 
     bool has_local(const std::string& key) const;
 
+    EnvResult find_local(const std::string& key);
+
     T& get_local(const std::string& key);
 
     // set variable on the current frame
-    void set_local(const std::string& key, T val);
+    void set_local(const std::string& key, const T& val);
+    void set_local(const std::string& key, T&& val);
 
     void del_local(const std::string& key);
 
@@ -60,7 +72,8 @@ namespace Sass {
     T& get_global(const std::string& key);
 
     // set a variable on the global frame
-    void set_global(const std::string& key, T val);
+    void set_global(const std::string& key, const T& val);
+    void set_global(const std::string& key, T&& val);
 
     void del_global(const std::string& key);
 
@@ -72,12 +85,17 @@ namespace Sass {
     // see if we have a lexical we could update
     // either update already existing lexical value
     // or we create a new one on the current frame
-    void set_lexical(const std::string& key, T val);
+    void set_lexical(const std::string& key, T&& val);
+    void set_lexical(const std::string& key, const T& val);
 
     // look on the full stack for key
     // include all scopes available
     bool has(const std::string& key) const;
 
+    // look on the full stack for key
+    // include all scopes available
+    EnvResult find(const std::string& key);
+
     // use array access for getter and setter functions
     T& operator[](const std::string& key);
 
@@ -87,6 +105,9 @@ namespace Sass {
 
   };
 
+  // define typedef for our use case
+  typedef Environment<AST_Node_Obj> Env;
+
 }
 
 #endif

data/ext/libsass/src/error_handling.cpp

@@ -10,19 +10,18 @@ namespace Sass {
 
   namespace Exception {
 
-    Base::Base(ParserState pstate, std::string msg, std::vector<Sass_Import_Entry>* import_stack)
+    Base::Base(ParserState pstate, std::string msg, Backtraces traces)
     : std::runtime_error(msg), msg(msg),
-      prefix("Error"), pstate(pstate),
-      import_stack(import_stack)
+      prefix("Error"), pstate(pstate), traces(traces)
     { }
 
-    InvalidSass::InvalidSass(ParserState pstate, std::string msg)
-    : Base(pstate, msg)
+    InvalidSass::InvalidSass(ParserState pstate, Backtraces traces, std::string msg)
+    : Base(pstate, msg, traces)
     { }
 
 
-    InvalidParent::InvalidParent(Selector_Ptr parent, Selector_Ptr selector)
-    : Base(selector->pstate()), parent(parent), selector(selector)
+    InvalidParent::InvalidParent(Selector_Ptr parent, Backtraces traces, Selector_Ptr selector)
+    : Base(selector->pstate(), def_msg, traces), parent(parent), selector(selector)
     {
       msg = "Invalid parent selector for \"";
       msg += selector->to_string(Sass_Inspect_Options());
@@ -31,8 +30,15 @@ namespace Sass {
       msg += "\"";
     }
 
-    InvalidArgumentType::InvalidArgumentType(ParserState pstate, std::string fn, std::string arg, std::string type, const Value_Ptr value)
-    : Base(pstate), fn(fn), arg(arg), type(type), value(value)
+    InvalidVarKwdType::InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument_Ptr arg)
+    : Base(pstate, def_msg, traces), name(name), arg(arg)
+    {
+      msg = "Variable keyword argument map must have string keys.\n";
+      msg += name + " is not a string in " + arg->to_string() + ".";
+    }
+
+    InvalidArgumentType::InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value_Ptr value)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)
     {
       msg  = arg + ": \"";
       if (value) msg += value->to_string(Sass_Inspect_Options());
@@ -40,46 +46,24 @@ namespace Sass {
       msg += " for `" + fn + "'";
     }
 
-    MissingArgument::MissingArgument(ParserState pstate, std::string fn, std::string arg, std::string fntype)
-    : Base(pstate), fn(fn), arg(arg), fntype(fntype)
+    MissingArgument::MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype)
+    : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)
     {
       msg  = fntype + " " + fn;
       msg += " is missing argument ";
       msg += arg + ".";
     }
 
-    InvalidSyntax::InvalidSyntax(ParserState pstate, std::string msg, std::vector<Sass_Import_Entry>* import_stack)
-    : Base(pstate, msg, import_stack)
+    InvalidSyntax::InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg)
+    : Base(pstate, msg, traces)
     { }
 
-    UndefinedOperation::UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
-    : lhs(lhs), rhs(rhs), op(op)
-    {
-      msg  = def_op_msg + ": \"";
-      msg += lhs->to_string({ NESTED, 5 });
-      msg += " " + op + " ";
-      msg += rhs->to_string({ TO_SASS, 5 });
-      msg += "\".";
-    }
-
-    InvalidNullOperation::InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
-    : UndefinedOperation(lhs, rhs, op)
-    {
-      msg  = def_op_null_msg + ": \"";
-      msg += lhs->inspect();
-      msg += " " + op + " ";
-      msg += rhs->inspect();
-      msg += "\".";
-    }
-
-    ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)
-    : lhs(lhs), rhs(rhs)
-    {
-      msg  = "divided by 0";
-    }
+    NestingLimitError::NestingLimitError(ParserState pstate, Backtraces traces, std::string msg)
+    : Base(pstate, msg, traces)
+    { }
 
-    DuplicateKeyError::DuplicateKeyError(const Map& dup, const Expression& org)
-    : Base(org.pstate()), dup(dup), org(org)
+    DuplicateKeyError::DuplicateKeyError(Backtraces traces, const Map& dup, const Expression& org)
+    : Base(org.pstate(), def_msg, traces), dup(dup), org(org)
     {
       msg  = "Duplicate key ";
       msg += dup.get_duplicate_key()->inspect();
@@ -88,8 +72,8 @@ namespace Sass {
       msg += ").";
     }
 
-    TypeMismatch::TypeMismatch(const Expression& var, const std::string type)
-    : Base(var.pstate()), var(var), type(type)
+    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const std::string type)
+    : Base(var.pstate(), def_msg, traces), var(var), type(type)
     {
       msg  = var.to_string();
       msg += " is not an ";
@@ -97,21 +81,20 @@ namespace Sass {
       msg += ".";
     }
 
-    InvalidValue::InvalidValue(const Expression& val)
-    : Base(val.pstate()), val(val)
+    InvalidValue::InvalidValue(Backtraces traces, const Expression& val)
+    : Base(val.pstate(), def_msg, traces), val(val)
     {
       msg  = val.to_string();
       msg += " isn't a valid CSS value.";
     }
 
-    StackError::StackError(const AST_Node& node)
-    : Base(node.pstate()), node(node)
+    StackError::StackError(Backtraces traces, const AST_Node& node)
+    : Base(node.pstate(), def_msg, traces), node(node)
     {
       msg  = "stack level too deep";
     }
 
-    IncompatibleUnits::IncompatibleUnits(const Number& lhs, const Number& rhs)
-    : lhs(lhs), rhs(rhs)
+    IncompatibleUnits::IncompatibleUnits(const Units& lhs, const Units& rhs)
     {
       msg  = "Incompatible units: '";
       msg += rhs.unit();
@@ -120,19 +103,53 @@ namespace Sass {
       msg += "'.";
     }
 
-    AlphaChannelsNotEqual::AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, const std::string& op)
-    : lhs(lhs), rhs(rhs), op(op)
+    IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)
+    {
+      msg  = "Incompatible units: '";
+      msg += unit_to_string(rhs);
+      msg += "' and '";
+      msg += unit_to_string(lhs);
+      msg += "'.";
+    }
+
+    AlphaChannelsNotEqual::AlphaChannelsNotEqual(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
     {
       msg  = "Alpha channels must be equal: ";
       msg += lhs->to_string({ NESTED, 5 });
-      msg += " " + op + " ";
+      msg += " " + sass_op_to_name(op) + " ";
       msg += rhs->to_string({ NESTED, 5 });
       msg += ".";
     }
 
+    ZeroDivisionError::ZeroDivisionError(const Expression& lhs, const Expression& rhs)
+    : OperationError(), lhs(lhs), rhs(rhs)
+    {
+      msg  = "divided by 0";
+    }
+
+    UndefinedOperation::UndefinedOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    : OperationError(), lhs(lhs), rhs(rhs), op(op)
+    {
+      msg  = def_op_msg + ": \"";
+      msg += lhs->to_string({ NESTED, 5 });
+      msg += " " + sass_op_to_name(op) + " ";
+      msg += rhs->to_string({ TO_SASS, 5 });
+      msg += "\".";
+    }
+
+    InvalidNullOperation::InvalidNullOperation(Expression_Ptr_Const lhs, Expression_Ptr_Const rhs, enum Sass_OP op)
+    : UndefinedOperation(lhs, rhs, op)
+    {
+      msg  = def_op_null_msg + ": \"";
+      msg += lhs->inspect();
+      msg += " " + sass_op_to_name(op) + " ";
+      msg += rhs->inspect();
+      msg += "\".";
+    }
 
-    SassValueError::SassValueError(ParserState pstate, OperationError& err)
-    : Base(pstate, err.what())
+    SassValueError::SassValueError(Backtraces traces, ParserState pstate, OperationError& err)
+    : Base(pstate, err.what(), traces)
     {
       msg = err.what();
       prefix = err.errtype();
@@ -143,13 +160,22 @@ namespace Sass {
 
   void warn(std::string msg, ParserState pstate)
   {
-    std::cerr << "Warning: " << msg<< std::endl;
+    std::cerr << "Warning: " << msg << std::endl;
+  }
+
+  void warning(std::string msg, ParserState pstate)
+  {
+    std::string cwd(Sass::File::get_cwd());
+    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
+    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
+    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+
+    std::cerr << "WARNING on line " << pstate.line+1 << ", column " << pstate.column+1 << " of " << output_path << ":" << std::endl;
+    std::cerr << msg << std::endl << std::endl;
   }
 
   void warn(std::string msg, ParserState pstate, Backtrace* bt)
   {
-    Backtrace top(bt, pstate, "");
-    msg += top.to_string();
     warn(msg, pstate);
   }
 
@@ -165,7 +191,7 @@ namespace Sass {
     std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
   }
 
-  void deprecated(std::string msg, std::string msg2, ParserState pstate)
+  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate)
   {
     std::string cwd(Sass::File::get_cwd());
     std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
@@ -173,9 +199,10 @@ namespace Sass {
     std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));
 
     std::cerr << "DEPRECATION WARNING on line " << pstate.line + 1;
+    if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
     if (output_path.length()) std::cerr << " of " << output_path;
     std::cerr << ":" << std::endl;
-    std::cerr << msg << " and will be an error in future versions of Sass." << std::endl;
+    std::cerr << msg << std::endl;
     if (msg2.length()) std::cerr << msg2 << std::endl;
     std::cerr << std::endl;
   }
@@ -192,16 +219,17 @@ namespace Sass {
     std::cerr << "This will be an error in future versions of Sass." << std::endl;
   }
 
-  void error(std::string msg, ParserState pstate)
+  // should be replaced with error with backtraces
+  void coreError(std::string msg, ParserState pstate)
   {
-    throw Exception::InvalidSyntax(pstate, msg);
+    Backtraces traces;
+    throw Exception::InvalidSyntax(pstate, traces, msg);
   }
 
-  void error(std::string msg, ParserState pstate, Backtrace* bt)
+  void error(std::string msg, ParserState pstate, Backtraces& traces)
   {
-    Backtrace top(bt, pstate, "");
-    msg += "\n" + top.to_string();
-    error(msg, pstate);
+    traces.push_back(Backtrace(pstate));
+    throw Exception::InvalidSyntax(pstate, traces, msg);
   }
 
 }