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

@@ -178,6 +178,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 >();
@@ -187,21 +201,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;
@@ -210,38 +221,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);
         }
 
       }
@@ -621,14 +626,14 @@ namespace Sass {
   Simple_Selector* Parser::parse_simple_selector()
   {
     lex < css_comments >();
-    if (lex< id_name >() || lex< class_name >()) {
+    if (lex< alternatives < id_name, class_name > >()) {
       return new (ctx.mem) Selector_Qualifier(pstate, unquote(lexed));
     }
-    else if (lex< quoted_string >() || lex< number >()) {
+    else if (lex< quoted_string >()) {
       return new (ctx.mem) Type_Selector(pstate, unquote(lexed));
     }
-    else if (lex< exactly < sel_deep_kwd > >()) {
-      return new (ctx.mem) Type_Selector(pstate, unquote(lexed));
+    else if (lex< alternatives < number, kwd_sel_deep > >()) {
+      return new (ctx.mem) Type_Selector(pstate, lexed);
     }
     else if (peek< pseudo_not >()) {
       return parse_negated_selector();

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;
 
   };
 

prelexer.cpp

@@ -197,6 +197,10 @@ namespace Sass {
       return sequence<exactly<'@'>, identifier>(src);
     }
 
+    const char* kwd_sel_deep(const char* src) {
+      return word<sel_deep_kwd>(src);
+    }
+
     const char* kwd_import(const char* src) {
       return word<import_kwd>(src);
     }

prelexer.hpp

@@ -172,6 +172,8 @@ namespace Sass {
     const char* identifier_alnums(const char* src);
     // Match selector names.
     // const char* sel_ident(const char* src);
+    const char* kwd_sel_deep(const char* src);
+
     // Match interpolant schemas
     const char* identifier_schema(const char* src);
     const char* value_schema(const char* src);