Add support for multiple importers

Call them in priority order so each one can decide if it
wants to handle a certain url. Return `null` to skip an
importer and to check the next one. Continue until one
returns a valid import. Otherwise libsass will handle it.

Author: mgreter

context.cpp

@@ -50,6 +50,8 @@ namespace Sass {
     this->source = source;
   }
 
+  inline bool sort_importers (const Sass_C_Importer_Call& i, const Sass_C_Importer_Call& j)
+  { return sass_importer_get_priority(i) < sass_importer_get_priority(j); }
 
   Context::Context(Context::Data initializers)
   : // Output(this),
@@ -61,7 +63,8 @@ namespace Sass {
     queue                   (vector<Sass_Queued>()),
     style_sheets            (map<string, Block*>()),
     emitter (this),
-    c_functions             (vector<Sass_C_Function_Callback>()),
+    c_functions             (vector<Sass_C_Function_Call>()),
+    c_importers             (vector<Sass_C_Importer_Call>()),
     indent                  (initializers.indent()),
     linefeed                (initializers.linefeed()),
     input_path              (make_canonical_path(initializers.input_path())),
@@ -74,7 +77,6 @@ namespace Sass {
     source_map_contents     (initializers.source_map_contents()),
     omit_source_map_url     (initializers.omit_source_map_url()),
     is_indented_syntax_src  (initializers.is_indented_syntax_src()),
-    importer                (initializers.importer()),
     names_to_colors         (map<string, Color*>()),
     colors_to_names         (map<int, string>()),
     precision               (initializers.precision()),
@@ -104,7 +106,11 @@ namespace Sass {
     for(auto fn : plugins.get_functions()) {
       c_functions.push_back(fn);
     }
+    for(auto fn : plugins.get_importers()) {
+      c_importers.push_back(fn);
+    }
 
+    sort (c_importers.begin(), c_importers.end(), sort_importers);
     string entry_point = initializers.entry_point();
     if (!entry_point.empty()) {
       string result(add_file(entry_point));
@@ -117,6 +123,17 @@ namespace Sass {
 
   }
 
+  void Context::add_c_function(Sass_C_Function_Call function)
+  {
+    c_functions.push_back(function);
+  }
+  void Context::add_c_importer(Sass_C_Importer_Call importer)
+  {
+    c_importers.push_back(importer);
+    // need to sort the array afterwards (no big deal)
+    sort (c_importers.begin(), c_importers.end(), sort_importers);
+  }
+
   Context::~Context()
   {
     // everything that gets put into sources will be freed by us
@@ -263,7 +280,7 @@ namespace Sass {
   void register_overload_stub(Context&, string name, Env* env);
   void register_built_in_functions(Context&, Env* env);
   void register_c_functions(Context&, Env* env, Sass_C_Function_List);
-  void register_c_function(Context&, Env* env, Sass_C_Function_Callback);
+  void register_c_function(Context&, Env* env, Sass_C_Function_Call);
 
   char* Context::compile_block(Block* root)
   {
@@ -515,7 +532,7 @@ namespace Sass {
       ++descrs;
     }
   }
-  void register_c_function(Context& ctx, Env* env, Sass_C_Function_Callback descr)
+  void register_c_function(Context& ctx, Env* env, Sass_C_Function_Call descr)
   {
     Definition* def = make_c_function(
       sass_function_get_signature(descr),

context.hpp

@@ -51,7 +51,12 @@ namespace Sass {
     map<string, Block*> style_sheets; // map of paths to ASTs
     // SourceMap source_map;
     Output emitter;
-    vector<Sass_C_Function_Callback> c_functions;
+
+    vector<Sass_C_Function_Call> c_functions;
+    vector<Sass_C_Importer_Call> c_importers;
+
+    void add_c_function(Sass_C_Function_Call function);
+    void add_c_importer(Sass_C_Importer_Call importer);
 
     string       indent; // String to be used for indentation
     string       linefeed; // String to be used for line feeds
@@ -67,7 +72,6 @@ namespace Sass {
     bool         is_indented_syntax_src; // treat source string as sass
 
     // overload import calls
-    Sass_C_Import_Callback importer;
     vector<struct Sass_Import*> import_stack;
 
     map<string, Color*> names_to_colors;
@@ -97,7 +101,6 @@ namespace Sass {
       KWD_ARG(Data, size_t,          precision);
       KWD_ARG(Data, bool,            source_map_embed);
       KWD_ARG(Data, bool,            source_map_contents);
-      KWD_ARG(Data, Sass_C_Import_Callback, importer);
     };
 
     Context(Data);

contrib/plugin.cpp

@@ -19,7 +19,7 @@ extern "C" const char* ADDCALL libsass_get_version() {
 extern "C" Sass_C_Function_List ADDCALL libsass_load_functions()
 {
   // allocate a custom function caller
-  Sass_C_Function_Callback fn_foo =
+  Sass_C_Function_Call fn_foo =
     sass_make_function("foo()", call_fn_foo, (void*)42);
   // create list of all custom functions
   Sass_C_Function_List fn_list = sass_make_function_list(1);

file.cpp

@@ -57,8 +57,9 @@ namespace Sass {
         return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
                (!(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)));
       #else
-        struct stat buffer;
-        return (stat (path.c_str(), &buffer) == 0);
+        struct stat st_buf;
+        return (stat (path.c_str(), &st_buf) == 0) &&
+               (!S_ISDIR (st_buf.st_mode));
       #endif
     }
 
@@ -284,7 +285,7 @@ namespace Sass {
     {
       if (paths == 0) return string("");
       vector<string> includes(0);
-      includes.push_back(".");
+      // includes.push_back(".");
       const char** it = paths;
       while (it && *it) {
         includes.push_back(*it);

parser.cpp

@@ -179,6 +179,20 @@ namespace Sass {
 
   }
 
+  void Parser::import_single_file (Import* imp, string import_path) {
+
+    if (!unquote(import_path).substr(0, 7).compare("http://") ||
+        !unquote(import_path).substr(0, 8).compare("https://") ||
+        !unquote(import_path).substr(0, 2).compare("//"))
+    {
+      imp->urls().push_back(new (ctx.mem) String_Quoted(pstate, import_path));
+    }
+    else {
+      add_single_file(imp, import_path);
+    }
+
+  }
+
   Import* Parser::parse_import()
   {
     lex< kwd_import >();
@@ -188,21 +202,18 @@ namespace Sass {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
         string import_path(lexed);
-
-        // struct Sass_Options opt = sass_context_get_options(ctx)
-        Sass_C_Import_Callback importer = ctx.importer;
-        // custom importer
-        if (importer) {
-          Sass_Import* current = ctx.import_stack.back();
-          Sass_C_Import_Fn fn = sass_import_get_function(importer);
-          void* cookie = sass_import_get_cookie(importer);
-          // create a new import entry
-          string inc_path = unquote(import_path);
-          struct Sass_Import** includes = fn(
-            inc_path.c_str(),
-            sass_import_get_path(current),
-            cookie);
-          if (includes) {
+        bool has_custom_import = false;
+        Sass_Import* current = ctx.import_stack.back();
+        const char* cur_path = sass_import_get_path(current);
+        string load_path = unquote(import_path);
+        for (auto importer : ctx.c_importers) {
+          if (has_custom_import) break;
+          Sass_C_Importer fn = sass_importer_get_function(importer);
+          // int priority = sass_importer_get_priority(importer);
+          void* cookie = sass_importer_get_cookie(importer);
+          if (struct Sass_Import** includes =
+              fn(load_path.c_str(), cur_path, cookie)
+          ) {
             struct Sass_Import** list = includes;
             while (*includes) {
               struct Sass_Import* include = *includes;
@@ -211,38 +222,32 @@ namespace Sass {
               size_t line = sass_import_get_error_line(include);
               size_t column = sass_import_get_error_column(include);
               const char* message = sass_import_get_error_message(include);
-              // char *srcmap = sass_import_take_srcmap(include);
               if (message) {
                 if (line == string::npos && column == string::npos) error(message, pstate);
                 else error(message, ParserState(message, source, Position(line, column)));
               } else if (source) {
                 if (file) {
-                  ctx.add_source(file, inc_path, source);
+                  ctx.add_source(file, load_path, source);
                   imp->files().push_back(file);
                 } else {
-                  ctx.add_source(inc_path, inc_path, source);
-                  imp->files().push_back(inc_path);
+                  ctx.add_source(load_path, load_path, source);
+                  imp->files().push_back(load_path);
                 }
               } else if(file) {
-                add_single_file(imp, file);
+                import_single_file(imp, file);
               }
               ++includes;
             }
             // deallocate returned memory
             sass_delete_import_list(list);
-            // parse next import
-            continue;
+            // break import chain
+            has_custom_import = true;
           }
         }
 
-        if (!unquote(import_path).substr(0, 7).compare("http://") ||
-            !unquote(import_path).substr(0, 8).compare("https://") ||
-            !unquote(import_path).substr(0, 2).compare("//"))
-        {
-          imp->urls().push_back(new (ctx.mem) String_Quoted(pstate, import_path));
-        }
-        else {
-          add_single_file(imp, import_path);
+        if (!has_custom_import) {
+          // push single file import
+          import_single_file(imp, import_path);
         }
 
       }

parser.hpp

@@ -25,6 +25,7 @@ namespace Sass {
   class Parser : public ParserState {
   private:
     void add_single_file (Import* imp, string import_path);
+    void import_single_file (Import* imp, string import_path);
   public:
     class AST_Node;
 

plugins.cpp

@@ -46,6 +46,7 @@ namespace Sass {
 
     typedef const char* (*__plugin_version__)(void);
     typedef Sass_C_Function_List (*__plugin_load_fns__)(void);
+    typedef Sass_C_Importer_List (*__plugin_load_imps__)(void);
 
     if (LOAD_LIB(plugin, path))
     {
@@ -60,6 +61,12 @@ namespace Sass {
           Sass_C_Function_List fns = plugin_load_functions();
           while (fns && *fns) { functions.push_back(*fns); ++ fns; }
         }
+        // try to get import address for "libsass_load_importers"
+        if (LOAD_LIB_FN(__plugin_load_imps__, plugin_load_importers, "libsass_load_importers"))
+        {
+          Sass_C_Importer_List imps = plugin_load_importers();
+          while (imps && *imps) { importers.push_back(*imps); ++ imps; }
+        }
         // success
         return true;
       }

plugins.hpp

@@ -42,12 +42,12 @@ namespace Sass {
       size_t load_plugins(const string& path);
 
     public: // public accessors
-      // const vector<Sass_C_Import_Callback> get_importers(void) { return importers; };
-      const vector<Sass_C_Function_Callback> get_functions(void) { return functions; };
+      const vector<Sass_C_Importer_Call> get_importers(void) { return importers; };
+      const vector<Sass_C_Function_Call> get_functions(void) { return functions; };
 
     private: // private vars
-      // vector<Sass_C_Import_Callback> importers;
-      vector<Sass_C_Function_Callback> functions;
+      vector<Sass_C_Importer_Call> importers;
+      vector<Sass_C_Function_Call> functions;
 
   };
 

sass_context.cpp

@@ -102,7 +102,7 @@ extern "C" {
     Sass_C_Function_List c_functions;
 
     // Callback to overload imports
-    Sass_C_Import_Callback importer;
+    Sass_C_Importer_List c_importers;
 
   };
 
@@ -405,7 +405,6 @@ extern "C" {
              // .plugin_paths_array(plugin_paths)
              .include_paths(vector<string>())
              .plugin_paths(vector<string>())
-             .importer(c_ctx->importer)
              .precision(c_ctx->precision ? c_ctx->precision : 5)
              .linefeed(c_ctx->linefeed ? c_ctx->linefeed : LFEED)
              .indent(c_ctx->indent ? c_ctx->indent : "  ");
@@ -418,13 +417,22 @@ extern "C" {
 
       // register our custom functions
       if (c_ctx->c_functions) {
-        Sass_C_Function_List this_func_data = c_ctx->c_functions;
-        while ((this_func_data) && (*this_func_data)) {
-          cpp_ctx->c_functions.push_back((*this_func_data));
+        auto this_func_data = c_ctx->c_functions;
+        while (this_func_data && *this_func_data) {
+          cpp_ctx->add_c_function(*this_func_data);
           ++this_func_data;
         }
       }
 
+      // register our custom importers
+      if (c_ctx->c_importers) {
+        auto this_imp_data = c_ctx->c_importers;
+        while (this_imp_data && *this_imp_data) {
+          cpp_ctx->add_c_importer(*this_imp_data);
+          ++this_imp_data;
+        }
+      }
+
       // reset error status
       c_ctx->error_json = 0;
       c_ctx->error_text = 0;
@@ -657,11 +665,19 @@ extern "C" {
     // Deallocate custom functions
     if (options->c_functions) {
       struct Sass_C_Function_Descriptor** this_func_data = options->c_functions;
-      while ((this_func_data) && (*this_func_data)) {
-        free((*this_func_data));
+      while (this_func_data && *this_func_data) {
+        free(*this_func_data);
         ++this_func_data;
       }
     }
+    // Deallocate custom importers
+    if (options->c_importers) {
+      struct Sass_C_Importer_Descriptor** this_imp_data = options->c_importers;
+      while (this_imp_data && *this_imp_data) {
+        free(*this_imp_data);
+        ++this_imp_data;
+      }
+    }
     // Deallocate inc paths
     if (options->plugin_paths) {
       struct string_list* cur;
@@ -686,13 +702,13 @@ extern "C" {
         cur = next;
       }
     }
-    // Free custom importer
-    free(options->importer);
-    // Free the list container
+    // Free custom functions
     free(options->c_functions);
-    // Make it null terminated
-    options->importer = 0;
+    // Free custom importers
+    free(options->c_importers);
+    // Reset our pointers
     options->c_functions = 0;
+    options->c_importers = 0;
     options->plugin_paths = 0;
     options->include_paths = 0;
   }
@@ -765,7 +781,7 @@ extern "C" {
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, omit_source_map_url);
   IMPLEMENT_SASS_OPTION_ACCESSOR(bool, is_indented_syntax_src);
   IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_C_Function_List, c_functions);
-  IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_C_Import_Callback, importer);
+  IMPLEMENT_SASS_OPTION_ACCESSOR(Sass_C_Importer_List, c_importers);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, indent);
   IMPLEMENT_SASS_OPTION_ACCESSOR(const char*, linefeed);
   IMPLEMENT_SASS_OPTION_STRING_ACCESSOR(const char*, input_path);

sass_context.h

@@ -75,7 +75,7 @@ ADDAPI const char* ADDCALL sass_option_get_include_path (struct Sass_Options* op
 ADDAPI const char* ADDCALL sass_option_get_source_map_file (struct Sass_Options* options);
 ADDAPI const char* ADDCALL sass_option_get_source_map_root (struct Sass_Options* options);
 ADDAPI Sass_C_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
-ADDAPI Sass_C_Import_Callback ADDCALL sass_option_get_importer (struct Sass_Options* options);
+ADDAPI Sass_C_Importer_List ADDCALL sass_option_get_c_importers (struct Sass_Options* options);
 
 // Setters for Context_Option values
 ADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);
@@ -94,7 +94,7 @@ ADDAPI void ADDCALL sass_option_set_include_path (struct Sass_Options* options,
 ADDAPI void ADDCALL sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);
 ADDAPI void ADDCALL sass_option_set_source_map_root (struct Sass_Options* options, const char* source_map_root);
 ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_C_Function_List c_functions);
-ADDAPI void ADDCALL sass_option_set_importer (struct Sass_Options* options, Sass_C_Import_Callback importer);
+ADDAPI void ADDCALL sass_option_set_c_importers (struct Sass_Options* options, Sass_C_Importer_List c_importers);
 
 
 // Getters for Sass_Context values