sassc 1.10.1 → 1.11.0

data/ext/libsass/src/parser.hpp

@@ -51,7 +51,7 @@ namespace Sass {
     static Parser from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate = ParserState("[CSTRING]"), const char* source = 0);
     static Parser from_token(Token t, Context& ctx, ParserState pstate = ParserState("[TOKEN]"), const char* source = 0);
     // special static parsers to convert strings into certain selectors
-    static Selector_List* parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
+    static CommaSequence_Selector* parse_selector(const char* src, Context& ctx, ParserState pstate = ParserState("[SELECTOR]"), const char* source = 0);
 
 #ifdef __clang__
 
@@ -66,6 +66,10 @@ namespace Sass {
 #endif
 
 
+    // skip current token and next whitespace
+    // moves ParserState right before next token
+    void advanceToNextToken();
+
     bool peek_newline(const char* start = 0);
 
     // skip over spaces, tabs and line comments
@@ -236,12 +240,11 @@ namespace Sass {
     Arguments* parse_arguments();
     Argument* parse_argument();
     Assignment* parse_assignment();
-    // Propset* parse_propset();
     Ruleset* parse_ruleset(Lookahead lookahead, bool is_root = false);
     Selector_Schema* parse_selector_schema(const char* end_of_selector);
-    Selector_List* parse_selector_list(bool at_root = false);
-    Complex_Selector* parse_complex_selector(bool in_root = true);
-    Compound_Selector* parse_compound_selector();
+    CommaSequence_Selector* parse_selector_list(bool at_root = false);
+    Sequence_Selector* parse_complex_selector(bool in_root = true);
+    SimpleSequence_Selector* parse_compound_selector();
     Simple_Selector* parse_simple_selector();
     Wrapped_Selector* parse_negated_selector();
     Simple_Selector* parse_pseudo_selector();
@@ -255,8 +258,8 @@ namespace Sass {
     Declaration* parse_declaration();
     Expression* parse_map_value();
     Expression* parse_map();
-    Expression* parse_list();
-    Expression* parse_comma_list();
+    Expression* parse_list(bool delayed = false);
+    Expression* parse_comma_list(bool delayed = false);
     Expression* parse_space_list();
     Expression* parse_disjunction();
     Expression* parse_conjunction();

data/ext/libsass/src/remove_placeholders.cpp

@@ -16,9 +16,9 @@ namespace Sass {
         }
     }
 
-    Selector_List* Remove_Placeholders::remove_placeholders(Selector_List* sl)
+    CommaSequence_Selector* Remove_Placeholders::remove_placeholders(CommaSequence_Selector* sl)
     {
-      Selector_List* new_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
+      CommaSequence_Selector* new_sl = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, sl->pstate());
 
       for (size_t i = 0, L = sl->length(); i < L; ++i) {
           if (!(*sl)[i]->contains_placeholder()) {
@@ -33,19 +33,19 @@ namespace Sass {
 
     void Remove_Placeholders::operator()(Ruleset* r) {
         // Create a new selector group without placeholders
-        Selector_List* sl = static_cast<Selector_List*>(r->selector());
+        CommaSequence_Selector* sl = static_cast<CommaSequence_Selector*>(r->selector());
 
         if (sl) {
           // Set the new placeholder selector list
           r->selector(remove_placeholders(sl));
           // Remove placeholders in wrapped selectors
-          for (Complex_Selector* cs : *sl) {
+          for (Sequence_Selector* cs : *sl) {
             while (cs) {
               if (cs->head()) {
                 for (Simple_Selector* ss : *cs->head()) {
                   if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(ss)) {
-                    if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
-                      Selector_List* clean = remove_placeholders(sl);
+                    if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
+                      CommaSequence_Selector* clean = remove_placeholders(sl);
                       // also clean superflous parent selectors
                       // probably not really the correct place
                       clean->remove_parent_selectors();

data/ext/libsass/src/remove_placeholders.hpp

@@ -18,7 +18,7 @@ namespace Sass {
         void fallback_impl(AST_Node* n) {}
 
     public:
-      Selector_List* remove_placeholders(Selector_List*);
+      CommaSequence_Selector* remove_placeholders(CommaSequence_Selector*);
 
     public:
         Remove_Placeholders(Context&);

data/ext/libsass/src/sass.cpp

@@ -70,3 +70,24 @@ extern "C" {
   }
 
 }
+
+namespace Sass {
+
+  // helper to aid dreaded MSVC debug mode
+  char* sass_copy_string(std::string str)
+  {
+    // In MSVC the following can lead to segfault:
+    // sass_copy_c_string(stream.str().c_str());
+    // Reason is that the string returned by str() is disposed before
+    // sass_copy_c_string is invoked. The string is actually a stack
+    // object, so indeed nobody is holding on to it. So it seems
+    // perfectly fair to release it right away. So the const char*
+    // by c_str will point to invalid memory. I'm not sure if this is
+    // the behavior for all compiler, but I'm pretty sure we would
+    // have gotten more issues reported if that would be the case.
+    // Wrapping it in a functions seems the cleanest approach as the
+    // function must hold on to the stack variable until it's done.
+    return sass_copy_c_string(str.c_str());
+  }
+
+}

data/ext/libsass/src/sass.hpp

@@ -45,6 +45,9 @@
 // include C-API header
 #include "sass/base.h"
 
+// For C++ helper
+#include <string>
+
 // output behaviours
 namespace Sass {
 
@@ -57,7 +60,11 @@ namespace Sass {
   const static Sass_Output_Style INSPECT = SASS_STYLE_INSPECT;
   const static Sass_Output_Style TO_SASS = SASS_STYLE_TO_SASS;
 
-};
+  // helper to aid dreaded MSVC debug mode
+  // see implementation for more details
+  char* sass_copy_string(std::string str);
+
+}
 
 // input behaviours
 enum Sass_Input_Style {

data/ext/libsass/src/sass2scss.cpp

@@ -574,6 +574,12 @@ namespace Sass
 					}
 				}
 
+				// check if we have a BEM property (one colon and no selector)
+				if (sass.substr(pos_left, 1) == ":" && converter.selector == true) {
+					size_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);
+					sass = indent + sass.substr(pos_left + 1, pos_wspace) + ":";
+				}
+
 			}
 
 			// terminate some statements immediately
@@ -584,10 +590,15 @@ namespace Sass
 				sass.substr(pos_left, 8) == "@charset"
 			) { sass = indent + sass.substr(pos_left); }
 			// replace some specific sass shorthand directives (if not fallowed by a white space character)
-			else if (sass.substr(pos_left, 1) == "=" && sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left) != pos_left + 1)
+			else if (sass.substr(pos_left, 1) == "=")
 			{ sass = indent + "@mixin " + sass.substr(pos_left + 1); }
-			else if (sass.substr(pos_left, 1) == "+" && sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left) != pos_left + 1)
-			{ sass = indent + "@include " + sass.substr(pos_left + 1); }
+			else if (sass.substr(pos_left, 1) == "+")
+			{
+				// must be followed by a mixin call (no whitespace afterwards or at ending directly)
+				if (sass[pos_left+1] != 0 && sass[pos_left+1] != ' ' && sass[pos_left+1] != '\t') {
+					sass = indent + "@include " + sass.substr(pos_left + 1);
+				}
+			}
 
 			// add quotes for import if needed
 			else if (sass.substr(pos_left, 7) == "@import")

data/ext/libsass/src/sass_context.cpp

@@ -17,10 +17,30 @@
 
 #define LFEED "\n"
 
+// C++ helper
+namespace Sass {
+  // see sass_copy_c_string(std::string str)
+  static inline JsonNode* json_mkstream(const std::stringstream& stream)
+  {
+    // hold on to string on stack!
+    std::string str(stream.str());
+    return json_mkstring(str.c_str());
+  }
+}
+
 extern "C" {
   using namespace Sass;
 
-  static void copy_options(struct Sass_Options* to, struct Sass_Options* from) { *to = *from; }
+  static void sass_clear_options (struct Sass_Options* options);
+  static void sass_reset_options (struct Sass_Options* options);
+  static void copy_options(struct Sass_Options* to, struct Sass_Options* from) {
+    // free assigned memory
+    sass_clear_options(to);
+    // move memory
+    *to = *from;
+    // Reset pointers on source
+    sass_reset_options(from);
+  }
 
   #define IMPLEMENT_SASS_OPTION_ACCESSOR(type, option) \
     type ADDCALL sass_option_get_##option (struct Sass_Options* options) { return options->option; } \
@@ -103,10 +123,9 @@ extern "C" {
       json_append_member(json_err, "line", json_mknumber((double)(e.pstate.line+1)));
       json_append_member(json_err, "column", json_mknumber((double)(e.pstate.column+1)));
       json_append_member(json_err, "message", json_mkstring(e.what()));
-      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
-
+      json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 1;
       c_ctx->error_file = sass_copy_c_string(e.pstate.path);
@@ -123,9 +142,9 @@ extern "C" {
       msg_stream << "Unable to allocate memory: " << ba.what() << std::endl;
       json_append_member(json_err, "status", json_mknumber(2));
       json_append_member(json_err, "message", json_mkstring(ba.what()));
-      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
+      json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(ba.what());
       c_ctx->error_status = 2;
       c_ctx->output_string = 0;
@@ -138,9 +157,9 @@ extern "C" {
       msg_stream << "Internal Error: " << e.what() << std::endl;
       json_append_member(json_err, "status", json_mknumber(3));
       json_append_member(json_err, "message", json_mkstring(e.what()));
-      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
+      json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 3;
       c_ctx->output_string = 0;
@@ -153,9 +172,9 @@ extern "C" {
       msg_stream << "Internal Error: " << e << std::endl;
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e.c_str()));
-      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
+      json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.c_str());
       c_ctx->error_status = 4;
       c_ctx->output_string = 0;
@@ -168,9 +187,9 @@ extern "C" {
       msg_stream << "Internal Error: " << e << std::endl;
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e));
-      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
+      json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e);
       c_ctx->error_status = 4;
       c_ctx->output_string = 0;
@@ -184,7 +203,7 @@ extern "C" {
       json_append_member(json_err, "status", json_mknumber(5));
       json_append_member(json_err, "message", json_mkstring("unknown"));
       try { c_ctx->error_json = json_stringify(json_err, "  "); } catch(...) {}
-      c_ctx->error_message = sass_copy_c_string(msg_stream.str().c_str());
+      c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string("unknown");
       c_ctx->error_status = 5;
       c_ctx->output_string = 0;
@@ -465,6 +484,24 @@ extern "C" {
     return 0;
   }
 
+  // helper function, not exported, only accessible locally
+  static void sass_reset_options (struct Sass_Options* options)
+  {
+    // free pointer before
+    // or copy/move them
+    options->input_path = 0;
+    options->output_path = 0;
+    options->plugin_path = 0;
+    options->include_path = 0;
+    options->source_map_file = 0;
+    options->source_map_root = 0;
+    options->c_functions = 0;
+    options->c_importers = 0;
+    options->c_headers = 0;
+    options->plugin_paths = 0;
+    options->include_paths = 0;
+  }
+
   // helper function, not exported, only accessible locally
   static void sass_clear_options (struct Sass_Options* options)
   {
@@ -517,12 +554,25 @@ extern "C" {
         cur = next;
       }
     }
+    // Free options strings
+    free(options->input_path);
+    free(options->output_path);
+    free(options->plugin_path);
+    free(options->include_path);
+    free(options->source_map_file);
+    free(options->source_map_root);
     // Free custom functions
     free(options->c_functions);
     // Free custom importers
     free(options->c_importers);
     free(options->c_headers);
     // Reset our pointers
+    options->input_path = 0;
+    options->output_path = 0;
+    options->plugin_path = 0;
+    options->include_path = 0;
+    options->source_map_file = 0;
+    options->source_map_root = 0;
     options->c_functions = 0;
     options->c_importers = 0;
     options->c_headers = 0;
@@ -542,12 +592,6 @@ extern "C" {
     if (ctx->error_text)        free(ctx->error_text);
     if (ctx->error_json)        free(ctx->error_json);
     if (ctx->error_file)        free(ctx->error_file);
-    if (ctx->input_path)        free(ctx->input_path);
-    if (ctx->output_path)       free(ctx->output_path);
-    if (ctx->plugin_path)       free(ctx->plugin_path);
-    if (ctx->include_path)      free(ctx->include_path);
-    if (ctx->source_map_file)   free(ctx->source_map_file);
-    if (ctx->source_map_root)   free(ctx->source_map_root);
     free_string_array(ctx->included_files);
     // play safe and reset properties
     ctx->output_string = 0;
@@ -556,11 +600,6 @@ extern "C" {
     ctx->error_text = 0;
     ctx->error_json = 0;
     ctx->error_file = 0;
-    ctx->input_path = 0;
-    ctx->output_path = 0;
-    ctx->include_path = 0;
-    ctx->source_map_file = 0;
-    ctx->source_map_root = 0;
     ctx->included_files = 0;
     // now clear the options
     sass_clear_options(ctx);
@@ -577,6 +616,11 @@ extern "C" {
     free(compiler);
   }
 
+  void ADDCALL sass_delete_options (struct Sass_Options* options)
+  {
+    sass_clear_options(options); free(options);
+  }
+
   // Deallocate all associated memory with file context
   void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx)
   {
@@ -623,6 +667,7 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_comments);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_embed);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_contents);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(bool, source_map_file_urls);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, omit_source_map_url);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, is_indented_syntax_src);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_Function_List, c_functions);

data/ext/libsass/src/sass_context.hpp

@@ -15,6 +15,9 @@ struct Sass_Options : Sass_Output_Options {
   // embed include contents in maps
   bool source_map_contents;
 
+  // create file urls for sources
+  bool source_map_file_urls;
+
   // Disable sourceMappingUrl in css output
   bool omit_source_map_url;
 

data/ext/libsass/src/source_map.cpp

@@ -25,20 +25,32 @@ namespace Sass {
 
     json_append_member(json_srcmap, "version", json_mknumber(3));
 
+    const char *include = file.c_str();
+    JsonNode *json_include = json_mkstring(include);
+    json_append_member(json_srcmap, "file", json_include);
+
     // pass-through sourceRoot option
     if (!ctx.source_map_root.empty()) {
       JsonNode* root = json_mkstring(ctx.source_map_root.c_str());
       json_append_member(json_srcmap, "sourceRoot", root);
     }
 
-    const char *include = file.c_str();
-    JsonNode *json_include = json_mkstring(include);
-    json_append_member(json_srcmap, "file", json_include);
-
     JsonNode *json_includes = json_mkarray();
     for (size_t i = 0; i < source_index.size(); ++i) {
-      const char *include = links[source_index[i]].c_str();
-      JsonNode *json_include = json_mkstring(include);
+      std::string include(links[source_index[i]]);
+      if (ctx.c_options.source_map_file_urls) {
+        include = File::rel2abs(include);
+        // check for windows abs path
+        if (include[0] == '/') {
+          // ends up with three slashes
+          include = "file://" + include;
+        } else {
+          // needs an additional slash
+          include = "file:///" + include;
+        }
+      }
+      const char* inc = include.c_str();
+      JsonNode *json_include = json_mkstring(inc);
       json_append_element(json_includes, json_include);
     }
     json_append_member(json_srcmap, "sources", json_includes);
@@ -54,15 +66,15 @@ namespace Sass {
         json_append_member(json_srcmap, "sourcesContent", json_contents);
     }
 
-    std::string mappings = serialize_mappings();
-    JsonNode *json_mappings = json_mkstring(mappings.c_str());
-    json_append_member(json_srcmap, "mappings", json_mappings);
-
     JsonNode *json_names = json_mkarray();
     // so far we have no implementation for names
     // no problem as we do not alter any identifiers
     json_append_member(json_srcmap, "names", json_names);
 
+    std::string mappings = serialize_mappings();
+    JsonNode *json_mappings = json_mkstring(mappings.c_str());
+    json_append_member(json_srcmap, "mappings", json_mappings);
+
     char *str = json_stringify(json_srcmap, "\t");
     std::string result = std::string(str);
     free(str);

data/ext/libsass/src/to_value.cpp

@@ -88,8 +88,8 @@ namespace Sass {
     return arg->value()->perform(this);
   }
 
-  // Selector_List is converted to a string
-  Value* To_Value::operator()(Selector_List* s)
+  // CommaSequence_Selector is converted to a string
+  Value* To_Value::operator()(CommaSequence_Selector* s)
   {
     return SASS_MEMORY_NEW(mem, String_Quoted,
                            s->pstate(),

data/ext/libsass/src/to_value.hpp

@@ -37,7 +37,7 @@ namespace Sass {
     Value* operator()(Null*);
 
     // convert to string via `To_String`
-    Value* operator()(Selector_List*);
+    Value* operator()(CommaSequence_Selector*);
     Value* operator()(Binary_Expression*);
 
     // fallback throws error