sassc 1.11.4 → 1.12.0

data/ext/libsass/src/check_nesting.hpp

@@ -6,11 +6,10 @@
 
 namespace Sass {
 
-  typedef Environment<AST_Node_Obj> Env;
-
   class CheckNesting : public Operation_CRTP<Statement_Ptr, CheckNesting> {
 
     std::vector<Statement_Ptr>  parents;
+    Backtraces                  traces;
     Statement_Ptr               parent;
     Definition_Ptr              current_mixin_definition;
 
@@ -24,10 +23,11 @@ namespace Sass {
 
     Statement_Ptr operator()(Block_Ptr);
     Statement_Ptr operator()(Definition_Ptr);
+    Statement_Ptr operator()(If_Ptr);
 
     template <typename U>
     Statement_Ptr fallback(U x) {
-      Statement_Ptr n = SASS_MEMORY_CAST_PTR(Statement, x);
+      Statement_Ptr n = Cast<Statement>(x);
       if (this->should_visit(n)) {
         return fallback_impl(n);
       }
@@ -35,17 +35,18 @@ namespace Sass {
     }
 
   private:
-    void invalid_content_parent(Statement_Ptr);
-    void invalid_charset_parent(Statement_Ptr);
-    void invalid_extend_parent(Statement_Ptr);
+    void invalid_content_parent(Statement_Ptr, AST_Node_Ptr);
+    void invalid_charset_parent(Statement_Ptr, AST_Node_Ptr);
+    void invalid_extend_parent(Statement_Ptr, AST_Node_Ptr);
     // void invalid_import_parent(Statement_Ptr);
-    void invalid_mixin_definition_parent(Statement_Ptr);
-    void invalid_function_parent(Statement_Ptr);
+    void invalid_mixin_definition_parent(Statement_Ptr, AST_Node_Ptr);
+    void invalid_function_parent(Statement_Ptr, AST_Node_Ptr);
 
     void invalid_function_child(Statement_Ptr);
     void invalid_prop_child(Statement_Ptr);
-    void invalid_prop_parent(Statement_Ptr);
-    void invalid_return_parent(Statement_Ptr);
+    void invalid_prop_parent(Statement_Ptr, AST_Node_Ptr);
+    void invalid_return_parent(Statement_Ptr, AST_Node_Ptr);
+    void invalid_value_child(AST_Node_Ptr);
 
     bool is_transparent_parent(Statement_Ptr, Statement_Ptr);
 

data/ext/libsass/src/color_maps.cpp

@@ -607,16 +607,20 @@ namespace Sass {
 
   Color_Ptr_Const name_to_color(const char* key)
   {
-    auto p = names_to_colors.find(key);
-    if (p != names_to_colors.end()) {
-      return p->second;
-    }
-    return 0;
+    return name_to_color(std::string(key));
   }
 
   Color_Ptr_Const name_to_color(const std::string& key)
   {
-    return name_to_color(key.c_str());
+    // case insensitive lookup.  See #2462
+    std::string lower{key};
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    auto p = names_to_colors.find(lower.c_str());
+    if (p != names_to_colors.end()) {
+      return p->second;
+    }
+    return 0;
   }
 
   const char* color_to_name(const int key)

data/ext/libsass/src/color_maps.hpp

@@ -1,3 +1,4 @@
+
 #ifndef SASS_COLOR_MAPS_H
 #define SASS_COLOR_MAPS_H
 
@@ -319,14 +320,11 @@ namespace Sass {
     extern const Color transparent;
   }
 
-  extern const std::map<const int, const char*> colors_to_names;
-  extern const std::map<const char*, Color_Ptr_Const, map_cmp_str> names_to_colors;
-
-  extern Color_Ptr_Const name_to_color(const char*);
-  extern Color_Ptr_Const name_to_color(const std::string&);
-  extern const char* color_to_name(const int);
-  extern const char* color_to_name(const Color&);
-  extern const char* color_to_name(const double);
+  Color_Ptr_Const name_to_color(const char*);
+  Color_Ptr_Const name_to_color(const std::string&);
+  const char* color_to_name(const int);
+  const char* color_to_name(const Color&);
+  const char* color_to_name(const double);
 
 }
 

data/ext/libsass/src/constants.cpp

@@ -79,11 +79,12 @@ namespace Sass {
     extern const char supports_kwd[]     = "@supports";
     extern const char keyframes_kwd[]    = "keyframes";
     extern const char only_kwd[]         = "only";
-    extern const char rgb_kwd[]          = "rgb(";
+    extern const char rgb_fn_kwd[]       = "rgb(";
+    extern const char url_fn_kwd[]       = "url(";
     extern const char url_kwd[]          = "url";
-    // extern const char url_prefix_kwd[]   = "url-prefix(";
+    // extern const char url_prefix_fn_kwd[] = "url-prefix(";
     extern const char important_kwd[]    = "important";
-    extern const char pseudo_not_kwd[]   = ":not(";
+    extern const char pseudo_not_fn_kwd[] = ":not(";
     extern const char even_kwd[]         = "even";
     extern const char odd_kwd[]          = "odd";
     extern const char progid_kwd[]       = "progid";

data/ext/libsass/src/constants.hpp

@@ -79,11 +79,12 @@ namespace Sass {
     extern const char supports_kwd[];
     extern const char keyframes_kwd[];
     extern const char only_kwd[];
-    extern const char rgb_kwd[];
+    extern const char rgb_fn_kwd[];
+    extern const char url_fn_kwd[];
     extern const char url_kwd[];
-    // extern const char url_prefix_kwd[];
+    // extern const char url_prefix_fn_kwd[];
     extern const char important_kwd[];
-    extern const char pseudo_not_kwd[];
+    extern const char pseudo_not_fn_kwd[];
     extern const char even_kwd[];
     extern const char odd_kwd[];
     extern const char progid_kwd[];

data/ext/libsass/src/context.cpp

@@ -67,11 +67,15 @@ namespace Sass {
     plugins(),
     emitter(c_options),
 
+    ast_gc(),
     strings(),
     resources(),
     sheets(),
     subset_map(),
     import_stack(),
+    callee_stack(),
+    traces(),
+    c_compiler(NULL),
 
     c_headers               (std::vector<Sass_Importer_Entry>()),
     c_importers             (std::vector<Sass_Importer_Entry>()),
@@ -87,10 +91,13 @@ namespace Sass {
 
   {
 
-    // add cwd to include paths
-    include_paths.push_back(CWD);
+    // Sass 3.4: The current working directory will no longer be placed onto the Sass load path by default.
+    // If you need the current working directory to be available, set SASS_PATH=. in your shell's environment.
+    // include_paths.push_back(CWD);
 
     // collect more paths from different options
+    collect_extensions(c_options.extension);
+    collect_extensions(c_options.extensions);
     collect_include_paths(c_options.include_path);
     collect_include_paths(c_options.include_paths);
     collect_plugin_paths(c_options.plugin_path);
@@ -129,7 +136,7 @@ namespace Sass {
 
   Context::~Context()
   {
-    // resources were allocated by strdup or malloc
+    // resources were allocated by malloc
     for (size_t i = 0; i < resources.size(); ++i) {
       free(resources[i].contents);
       free(resources[i].srcmap);
@@ -161,6 +168,37 @@ namespace Sass {
   {
   }
 
+  void Context::collect_extensions(const char* exts_str)
+  {
+    if (exts_str) {
+      const char* beg = exts_str;
+      const char* end = Prelexer::find_first<PATH_SEP>(beg);
+
+      while (end) {
+        std::string ext(beg, end - beg);
+        if (!ext.empty()) {
+          extensions.push_back(ext);
+        }
+        beg = end + 1;
+        end = Prelexer::find_first<PATH_SEP>(beg);
+      }
+
+      std::string ext(beg);
+      if (!ext.empty()) {
+        extensions.push_back(ext);
+      }
+    }
+  }
+
+  void Context::collect_extensions(string_list* paths_array)
+  {
+    while (paths_array)
+    {
+      collect_extensions(paths_array->string);
+      paths_array = paths_array->next;
+    }
+  }
+
   void Context::collect_include_paths(const char* paths_str)
   {
     if (paths_str) {
@@ -231,25 +269,29 @@ namespace Sass {
   // looks for alternatives and returns a list from one directory
   std::vector<Include> Context::find_includes(const Importer& import)
   {
+    // include configured extensions
+    std::vector<std::string> exts(File::defaultExtensions);
+    if (extensions.size() > 0) {
+      exts.insert(exts.end(), extensions.begin(), extensions.end());
+    }
     // make sure we resolve against an absolute path
     std::string base_path(rel2abs(import.base_path));
     // first try to resolve the load path relative to the base path
-    std::vector<Include> vec(resolve_includes(base_path, import.imp_path));
+    std::vector<Include> vec(resolve_includes(base_path, import.imp_path, exts));
     // then search in every include path (but only if nothing found yet)
     for (size_t i = 0, S = include_paths.size(); vec.size() == 0 && i < S; ++i)
     {
       // call resolve_includes and individual base path and append all results
-      std::vector<Include> resolved(resolve_includes(include_paths[i], import.imp_path));
+      std::vector<Include> resolved(resolve_includes(include_paths[i], import.imp_path, exts));
       if (resolved.size()) vec.insert(vec.end(), resolved.begin(), resolved.end());
     }
     // return vector
     return vec;
   }
 
-
   // register include with resolved path and its content
   // memory of the resources will be freed by us on exit
-  void Context::register_resource(const Include& inc, const Resource& res, ParserState* prstate)
+  void Context::register_resource(const Include& inc, const Resource& res)
   {
 
     // do not parse same resource twice
@@ -297,21 +339,22 @@ namespace Sass {
     for (size_t i = 0; i < import_stack.size() - 2; ++i) {
       auto parent = import_stack[i];
       if (std::strcmp(parent->abs_path, import->abs_path) == 0) {
+        std::string cwd(File::get_cwd());
+        // make path relative to the current directory
         std::string stack("An @import loop has been found:");
         for (size_t n = 1; n < i + 2; ++n) {
-          stack += "\n    " + std::string(import_stack[n]->imp_path) +
-            " imports " + std::string(import_stack[n+1]->imp_path);
+          stack += "\n    " + std::string(File::abs2rel(import_stack[n]->abs_path, cwd, cwd)) +
+            " imports " + std::string(File::abs2rel(import_stack[n+1]->abs_path, cwd, cwd));
         }
         // implement error throw directly until we
         // decided how to handle full stack traces
-        ParserState state = prstate ? *prstate : pstate;
-        throw Exception::InvalidSyntax(state, stack, &import_stack);
+        throw Exception::InvalidSyntax(pstate, traces, stack);
         // error(stack, prstate ? *prstate : pstate, import_stack);
       }
     }
 
     // create a parser instance from the given c_str buffer
-    Parser p(Parser::from_c_str(contents, *this, pstate));
+    Parser p(Parser::from_c_str(contents, *this, traces, pstate));
     // do not yet dispose these buffers
     sass_import_take_source(import);
     sass_import_take_srcmap(import);
@@ -326,7 +369,15 @@ namespace Sass {
       ast_pair(inc.abs_path, { res, root });
     // register resulting resource
     sheets.insert(ast_pair);
+  }
 
+  // register include with resolved path and its content
+  // memory of the resources will be freed by us on exit
+  void Context::register_resource(const Include& inc, const Resource& res, ParserState& prstate)
+  {
+    traces.push_back(Backtrace(prstate));
+    register_resource(inc, res);
+    traces.pop_back();
   }
 
   // Add a new import to the context (called from `import_url`)
@@ -346,19 +397,27 @@ namespace Sass {
       for (size_t i = 0, L = resolved.size(); i < L; ++i)
       { msg_stream << "  " << resolved[i].imp_path << "\n"; }
       msg_stream << "Please delete or rename all but one of these files." << "\n";
-      error(msg_stream.str(), pstate);
+      error(msg_stream.str(), pstate, traces);
     }
 
     // process the resolved entry
     else if (resolved.size() == 1) {
       bool use_cache = c_importers.size() == 0;
+      if (resolved[0].deprecated) {
+        // emit deprecation warning when import resolves to a .css file
+        deprecated(
+          "Including .css files with @import is non-standard behaviour which will be removed in future versions of LibSass.",
+          "Use a custom importer to maintain this behaviour. Check your implementations documentation on how to create a custom importer.",
+          true, pstate
+        );
+      }
       // use cache for the resource loading
       if (use_cache && sheets.count(resolved[0].abs_path)) return resolved[0];
       // try to read the content of the resolved file entry
       // the memory buffer returned must be freed by us!
       if (char* contents = read_file(resolved[0].abs_path)) {
         // register the newly resolved file resource
-        register_resource(resolved[0], { contents, 0 }, &pstate);
+        register_resource(resolved[0], { contents, 0 }, pstate);
         // return resolved entry
         return resolved[0];
       }
@@ -391,15 +450,15 @@ namespace Sass {
       String_Constant_Ptr loc = SASS_MEMORY_NEW(String_Constant, pstate, unquote(load_path));
       Argument_Obj loc_arg = SASS_MEMORY_NEW(Argument, pstate, loc);
       Arguments_Obj loc_args = SASS_MEMORY_NEW(Arguments, pstate);
-      loc_args->append(&loc_arg);
-      Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "url", &loc_args);
+      loc_args->append(loc_arg);
+      Function_Call_Ptr new_url = SASS_MEMORY_NEW(Function_Call, pstate, "url", loc_args);
       imp->urls().push_back(new_url);
     }
     else {
       const Importer importer(imp_path, ctx_path);
       Include include(load_import(importer, pstate));
       if (include.abs_path.empty()) {
-        error("File to import not found or unreadable: " + imp_path + ".\nParent style sheet: " + ctx_path, pstate);
+        error("File to import not found or unreadable: " + imp_path + ".", pstate, traces);
       }
       imp->incs().push_back(include);
     }
@@ -415,12 +474,12 @@ namespace Sass {
     // need one correct import
     bool has_import = false;
     // process all custom importers (or custom headers)
-    for (Sass_Importer_Entry& importer : importers) {
+    for (Sass_Importer_Entry& importer_ent : importers) {
       // int priority = sass_importer_get_priority(importer);
-      Sass_Importer_Fn fn = sass_importer_get_function(importer);
+      Sass_Importer_Fn fn = sass_importer_get_function(importer_ent);
       // skip importer if it returns NULL
       if (Sass_Import_List includes =
-          fn(load_path.c_str(), importer, c_compiler)
+          fn(load_path.c_str(), importer_ent, c_compiler)
       ) {
         // get c pointer copy to iterate over
         Sass_Import_List it_includes = includes;
@@ -435,18 +494,18 @@ namespace Sass {
           // create the importer struct
           Importer importer(uniq_path, ctx_path);
           // query data from the current include
-          Sass_Import_Entry include = *it_includes;
-          char* source = sass_import_take_source(include);
-          char* srcmap = sass_import_take_srcmap(include);
-          size_t line = sass_import_get_error_line(include);
-          size_t column = sass_import_get_error_column(include);
-          const char *abs_path = sass_import_get_abs_path(include);
+          Sass_Import_Entry include_ent = *it_includes;
+          char* source = sass_import_take_source(include_ent);
+          char* srcmap = sass_import_take_srcmap(include_ent);
+          size_t line = sass_import_get_error_line(include_ent);
+          size_t column = sass_import_get_error_column(include_ent);
+          const char *abs_path = sass_import_get_abs_path(include_ent);
           // handle error message passed back from custom importer
           // it may (or may not) override the line and column info
-          if (const char* err_message = sass_import_get_error_message(include)) {
-            if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap }, &pstate);
-            if (line == std::string::npos && column == std::string::npos) error(err_message, pstate);
-            else error(err_message, ParserState(ctx_path, source, Position(line, column)));
+          if (const char* err_message = sass_import_get_error_message(include_ent)) {
+            if (source || srcmap) register_resource({ importer, uniq_path }, { source, srcmap }, pstate);
+            if (line == std::string::npos && column == std::string::npos) error(err_message, pstate, traces);
+            else error(err_message, ParserState(ctx_path, source, Position(line, column)), traces);
           }
           // content for import was set
           else if (source) {
@@ -458,7 +517,7 @@ namespace Sass {
             // attach information to AST node
             imp->incs().push_back(include);
             // register the resource buffers
-            register_resource(include, { source, srcmap }, &pstate);
+            register_resource(include, { source, srcmap }, pstate);
           }
           // only a path was retuned
           // try to load it like normal
@@ -528,11 +587,11 @@ namespace Sass {
     Import_Obj imp = SASS_MEMORY_NEW(Import, pstate);
     // dispatch headers which will add custom functions
     // custom headers are added to the import instance
-    call_headers(entry_path, ctx_path, pstate, &imp);
+    call_headers(entry_path, ctx_path, pstate, imp);
     // increase head count to skip later
     head_imports += resources.size() - 1;
     // add the statement if we have urls
-    if (!imp->urls().empty()) root->append(&imp);
+    if (!imp->urls().empty()) root->append(imp);
     // process all other resources (add Import_Stub nodes)
     for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {
       root->append(SASS_MEMORY_NEW(Import_Stub, pstate, imp->incs()[i]));
@@ -644,30 +703,33 @@ namespace Sass {
     for (size_t i = 0, S = c_functions.size(); i < S; ++i)
     { register_c_function(*this, &global, c_functions[i]); }
     // create initial backtrace entry
-    Backtrace backtrace(0, ParserState("", 0), "");
     // create crtp visitor objects
-    Expand expand(*this, &global, &backtrace);
-    Cssize cssize(*this, &backtrace);
+    Expand expand(*this, &global);
+    Cssize cssize(*this);
     CheckNesting check_nesting;
-    // check nesting
-    check_nesting(&root);
+    // check nesting in all files
+    for (auto sheet : sheets) {
+      auto styles = sheet.second;
+      check_nesting(styles.root);
+    }
     // expand and eval the tree
-    root = expand(&root);
+    root = expand(root);
     // check nesting
-    check_nesting(&root);
+    check_nesting(root);
     // merge and bubble certain rules
-    root = cssize(&root);
+    root = cssize(root);
     // should we extend something?
     if (!subset_map.empty()) {
       // create crtp visitor object
-      Extend extend(*this, subset_map);
+      Extend extend(subset_map);
+      extend.setEval(expand.eval);
       // extend tree nodes
-      extend(&root);
+      extend(root);
     }
 
     // clean up by removing empty placeholders
     // ToDo: maybe we can do this somewhere else?
-    Remove_Placeholders remove_placeholders(*this);
+    Remove_Placeholders remove_placeholders;
     root->perform(&remove_placeholders);
     // return processed tree
     return root;
@@ -695,10 +757,8 @@ namespace Sass {
   char* Context::render_srcmap()
   {
     if (source_map_file == "") return 0;
-    char* result = 0;
     std::string map = emitter.render_srcmap(*this);
-    result = sass_copy_c_string(map.c_str());
-    return result;
+    return sass_copy_c_string(map.c_str());
   }
 
 
@@ -810,6 +870,7 @@ namespace Sass {
     register_function(ctx, append_sig, append, env);
     register_function(ctx, zip_sig, zip, env);
     register_function(ctx, list_separator_sig, list_separator, env);
+    register_function(ctx, is_bracketed_sig, is_bracketed, env);
     // Map Functions
     register_function(ctx, map_get_sig, map_get, env);
     register_function(ctx, map_merge_sig, map_merge, env);
@@ -829,6 +890,8 @@ namespace Sass {
     register_function(ctx, mixin_exists_sig, mixin_exists, env);
     register_function(ctx, feature_exists_sig, feature_exists, env);
     register_function(ctx, call_sig, call, env);
+    register_function(ctx, content_exists_sig, content_exists, env);
+    register_function(ctx, get_function_sig, get_function, env);
     // Boolean Functions
     register_function(ctx, not_sig, sass_not, env);
     register_function(ctx, if_sig, sass_if, env);