sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/file.cpp

@@ -13,7 +13,6 @@
 #else
 # include <unistd.h>
 #endif
-#include <cctype>
 #include <cstdio>
 #include <vector>
 #include <algorithm>
@@ -25,6 +24,7 @@
 #include "sass_functions.hpp"
 #include "error_handling.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 #include "sass2scss.h"
 
 #ifdef _WIN32
@@ -32,16 +32,16 @@
 
 # ifdef _MSC_VER
 # include <codecvt>
-inline static std::string wstring_to_string(const std::wstring& wstr)
+inline static Sass::sass::string wstring_to_string(const std::wstring& wstr)
 {
     std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> wchar_converter;
     return wchar_converter.to_bytes(wstr);
 }
 # else // mingw(/gcc) does not support C++11's codecvt yet.
-inline static std::string wstring_to_string(const std::wstring &wstr)
+inline static Sass::sass::string wstring_to_string(const std::wstring &wstr)
 {
     int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
-    std::string strTo(size_needed, 0);
+    Sass::sass::string strTo(size_needed, 0);
     WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
     return strTo;
 }
@@ -54,7 +54,7 @@ namespace Sass {
     // return the current directory
     // always with forward slashes
     // always with trailing slash
-    std::string get_cwd()
+    sass::string get_cwd()
     {
       const size_t wd_len = 4096;
       #ifndef _WIN32
@@ -63,12 +63,12 @@ namespace Sass {
         // we should check error for more detailed info (e.g. ENOENT)
         // http://man7.org/linux/man-pages/man2/getcwd.2.html#ERRORS
         if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
-        std::string cwd = pwd;
+        sass::string cwd = pwd;
       #else
         wchar_t wd[wd_len];
         wchar_t* pwd = _wgetcwd(wd, wd_len);
         if (pwd == NULL) throw Exception::OperationError("cwd gone missing");
-        std::string cwd = wstring_to_string(pwd);
+        sass::string cwd = wstring_to_string(pwd);
         //convert backslashes to forward slashes
         replace(cwd.begin(), cwd.end(), '\\', '/');
       #endif
@@ -77,12 +77,12 @@ namespace Sass {
     }
 
     // test if path exists and is a file
-    bool file_exists(const std::string& path)
+    bool file_exists(const sass::string& path)
     {
       #ifdef _WIN32
         wchar_t resolved[32768];
         // windows unicode filepaths are encoded in utf16
-        std::string abspath(join_paths(get_cwd(), path));
+        sass::string abspath(join_paths(get_cwd(), path));
         if (!(abspath[0] == '/' && abspath[1] == '/')) {
           abspath = "//?/" + abspath;
         }
@@ -103,35 +103,35 @@ namespace Sass {
 
     // return if given path is absolute
     // works with *nix and windows paths
-    bool is_absolute_path(const std::string& path)
+    bool is_absolute_path(const sass::string& path)
     {
       #ifdef _WIN32
-        if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;
+        if (path.length() >= 2 && Util::ascii_isalpha(path[0]) && path[1] == ':') return true;
       #endif
       size_t i = 0;
       // check if we have a protocol
-      if (path[i] && Prelexer::is_alpha(path[i])) {
+      if (path[i] && Util::ascii_isalpha(static_cast<unsigned char>(path[i]))) {
         // skip over all alphanumeric characters
-        while (path[i] && Prelexer::is_alnum(path[i])) ++i;
+        while (path[i] && Util::ascii_isalnum(static_cast<unsigned char>(path[i]))) ++i;
         i = i && path[i] == ':' ? i + 1 : 0;
       }
       return path[i] == '/';
     }
 
-    // helper function to find the last directory seperator
-    inline size_t find_last_folder_separator(const std::string& path, size_t limit = std::string::npos)
+    // helper function to find the last directory separator
+    inline size_t find_last_folder_separator(const sass::string& path, size_t limit = sass::string::npos)
     {
       size_t pos;
       size_t pos_p = path.find_last_of('/', limit);
       #ifdef _WIN32
         size_t pos_w = path.find_last_of('\\', limit);
       #else
-        size_t pos_w = std::string::npos;
+        size_t pos_w = sass::string::npos;
       #endif
-      if (pos_p != std::string::npos && pos_w != std::string::npos) {
+      if (pos_p != sass::string::npos && pos_w != sass::string::npos) {
         pos = std::max(pos_p, pos_w);
       }
-      else if (pos_p != std::string::npos) {
+      else if (pos_p != sass::string::npos) {
         pos = pos_p;
       }
       else {
@@ -141,24 +141,24 @@ namespace Sass {
     }
 
     // return only the directory part of path
-    std::string dir_name(const std::string& path)
+    sass::string dir_name(const sass::string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == std::string::npos) return "";
+      if (pos == sass::string::npos) return "";
       else return path.substr(0, pos+1);
     }
 
     // return only the filename part of path
-    std::string base_name(const std::string& path)
+    sass::string base_name(const sass::string& path)
     {
       size_t pos = find_last_folder_separator(path);
-      if (pos == std::string::npos) return path;
+      if (pos == sass::string::npos) return path;
       else return path.substr(pos+1);
     }
 
     // do a logical clean up of the path
     // no physical check on the filesystem
-    std::string make_canonical_path (std::string path)
+    sass::string make_canonical_path (sass::string path)
     {
 
       // declarations
@@ -170,18 +170,18 @@ namespace Sass {
       #endif
 
       pos = 0; // remove all self references inside the path string
-      while((pos = path.find("/./", pos)) != std::string::npos) path.erase(pos, 2);
+      while((pos = path.find("/./", pos)) != sass::string::npos) path.erase(pos, 2);
 
       // remove all leading and trailing self references
-      while(path.length() > 1 && path.substr(0, 2) == "./") path.erase(0, 2);
-      while((pos = path.length()) > 1 && path.substr(pos - 2) == "/.") path.erase(pos - 2);
+      while(path.size() >= 2 && path[0] == '.' && path[1] == '/') path.erase(0, 2);
+      while((pos = path.length()) > 1 && path[pos - 2] == '/' && path[pos - 1] == '.') path.erase(pos - 2);
 
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -190,7 +190,7 @@ namespace Sass {
       while (path[proto++] == '/') {}
 
       pos = proto; // collapse multiple delimiters into a single one
-      while((pos = path.find("//", pos)) != std::string::npos) path.erase(pos, 1);
+      while((pos = path.find("//", pos)) != sass::string::npos) path.erase(pos, 1);
 
       return path;
 
@@ -198,7 +198,7 @@ namespace Sass {
 
     // join two path segments cleanly together
     // but only if right side is not absolute yet
-    std::string join_paths(std::string l, std::string r)
+    sass::string join_paths(sass::string l, sass::string r)
     {
 
       #ifdef _WIN32
@@ -225,16 +225,16 @@ namespace Sass {
         bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\');
         bool is_self = pos + 3 == L && (l[pos+1] == '.');
         if (!is_self && !is_slash) r = r.substr(3);
-        else if (pos == std::string::npos) break;
-        l = l.substr(0, pos == std::string::npos ? pos : pos + 1);
+        else if (pos == sass::string::npos) break;
+        l = l.substr(0, pos == sass::string::npos ? pos : pos + 1);
       }
 
       return l + r;
     }
 
-    std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path)
+    sass::string path_for_console(const sass::string& rel_path, const sass::string& abs_path, const sass::string& orig_path)
     {
-      // magic algorith goes here!!
+      // magic algorithm goes here!!
 
       // if the file is outside this directory show the absolute path
       if (rel_path.substr(0, 3) == "../") {
@@ -245,24 +245,32 @@ namespace Sass {
     }
 
     // create an absolute path by resolving relative paths with cwd
-    std::string rel2abs(const std::string& path, const std::string& base, const std::string& cwd)
+    sass::string rel2abs(const sass::string& path, const sass::string& base, const sass::string& cwd)
     {
-      return make_canonical_path(join_paths(join_paths(cwd + "/", base + "/"), path));
+      sass::string rv = make_canonical_path(join_paths(join_paths(cwd + "/", base + "/"), path));
+      #ifdef _WIN32
+      // On windows we may get an absolute path without directory
+      // In that case we should prepend the directory from the root
+      if (rv[0] == '/' && rv[1] != '/') {
+        rv.insert(0, cwd, 0, 2);
+      }
+      #endif
+      return rv;
     }
 
     // create a path that is relative to the given base directory
     // path and base will first be resolved against cwd to make them absolute
-    std::string abs2rel(const std::string& path, const std::string& base, const std::string& cwd)
+    sass::string abs2rel(const sass::string& path, const sass::string& base, const sass::string& cwd)
     {
 
-      std::string abs_path = rel2abs(path, cwd);
-      std::string abs_base = rel2abs(base, cwd);
+      sass::string abs_path = rel2abs(path, cwd);
+      sass::string abs_base = rel2abs(base, cwd);
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -277,8 +285,8 @@ namespace Sass {
         if (abs_base[0] != abs_path[0]) return abs_path;
       #endif
 
-      std::string stripped_uri = "";
-      std::string stripped_base = "";
+      sass::string stripped_uri = "";
+      sass::string stripped_base = "";
 
       size_t index = 0;
       size_t minSize = std::min(abs_path.size(), abs_base.size());
@@ -288,7 +296,8 @@ namespace Sass {
         #else
           // compare the charactes in a case insensitive manner
           // windows fs is only case insensitive in ascii ranges
-          if (tolower(abs_path[i]) != tolower(abs_base[i])) break;
+          if (Util::ascii_tolower(static_cast<unsigned char>(abs_path[i])) !=
+              Util::ascii_tolower(static_cast<unsigned char>(abs_base[i]))) break;
         #endif
         if (abs_path[i] == '/') index = i + 1;
       }
@@ -316,7 +325,7 @@ namespace Sass {
         }
       }
 
-      std::string result = "";
+      sass::string result = "";
       for (size_t i = 0; i < directories; ++i) {
         result += "../";
       }
@@ -332,16 +341,16 @@ namespace Sass {
     // (4) given + extension
     // (5) given + _index.scss
     // (6) given + _index.sass
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file, const std::vector<std::string>& exts)
+    sass::vector<Include> resolve_includes(const sass::string& root, const sass::string& file, const sass::vector<sass::string>& exts)
     {
-      std::string filename = join_paths(root, file);
+      sass::string filename = join_paths(root, file);
       // split the filename
-      std::string base(dir_name(file));
-      std::string name(base_name(file));
-      std::vector<Include> includes;
+      sass::string base(dir_name(file));
+      sass::string name(base_name(file));
+      sass::vector<Include> includes;
       // create full path (maybe relative)
-      std::string rel_path(join_paths(base, name));
-      std::string abs_path(join_paths(root, rel_path));
+      sass::string rel_path(join_paths(base, name));
+      sass::string abs_path(join_paths(root, rel_path));
       if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       // next test variation with underscore
       rel_path = join_paths(base, "_" + name);
@@ -382,24 +391,24 @@ namespace Sass {
       return includes;
     }
 
-    std::vector<std::string> find_files(const std::string& file, const std::vector<std::string> paths)
+    sass::vector<sass::string> find_files(const sass::string& file, const sass::vector<sass::string> paths)
     {
-      std::vector<std::string> includes;
-      for (std::string path : paths) {
-        std::string abs_path(join_paths(path, file));
+      sass::vector<sass::string> includes;
+      for (sass::string path : paths) {
+        sass::string abs_path(join_paths(path, file));
         if (file_exists(abs_path)) includes.push_back(abs_path);
       }
       return includes;
     }
 
-    std::vector<std::string> find_files(const std::string& file, struct Sass_Compiler* compiler)
+    sass::vector<sass::string> find_files(const sass::string& file, struct Sass_Compiler* compiler)
     {
       // get the last import entry to get current base directory
       // struct Sass_Options* options = sass_compiler_get_options(compiler);
       Sass_Import_Entry import = sass_compiler_get_last_import(compiler);
-      const std::vector<std::string>& incs = compiler->cpp_ctx->include_paths;
+      const sass::vector<sass::string>& incs = compiler->cpp_ctx->include_paths;
       // create the vector with paths to lookup
-      std::vector<std::string> paths(1 + incs.size());
+      sass::vector<sass::string> paths(1 + incs.size());
       paths.push_back(dir_name(import->abs_path));
       paths.insert(paths.end(), incs.begin(), incs.end());
       // dispatch to find files in paths
@@ -408,7 +417,7 @@ namespace Sass {
 
     // helper function to search one file in all include paths
     // this is normally not used internally by libsass (C-API sugar)
-    std::string find_file(const std::string& file, const std::vector<std::string> paths)
+    sass::string find_file(const sass::string& file, const sass::vector<sass::string> paths)
     {
       if (file.empty()) return file;
       auto res = find_files(file, paths);
@@ -416,29 +425,29 @@ namespace Sass {
     }
 
     // helper function to resolve a filename
-    std::string find_include(const std::string& file, const std::vector<std::string> paths)
+    sass::string find_include(const sass::string& file, const sass::vector<sass::string> paths)
     {
       // search in every include path for a match
       for (size_t i = 0, S = paths.size(); i < S; ++i)
       {
-        std::vector<Include> resolved(resolve_includes(paths[i], file));
+        sass::vector<Include> resolved(resolve_includes(paths[i], file));
         if (resolved.size()) return resolved[0].abs_path;
       }
       // nothing found
-      return std::string("");
+      return sass::string("");
     }
 
     // try to load the given filename
     // returned memory must be freed
     // will auto convert .sass files
-    char* read_file(const std::string& path)
+    char* read_file(const sass::string& path)
     {
       #ifdef _WIN32
         BYTE* pBuffer;
         DWORD dwBytes;
         wchar_t resolved[32768];
         // windows unicode filepaths are encoded in utf16
-        std::string abspath(join_paths(get_cwd(), path));
+        sass::string abspath(join_paths(get_cwd(), path));
         if (!(abspath[0] == '/' && abspath[1] == '/')) {
           abspath = "//?/" + abspath;
         }
@@ -474,6 +483,7 @@ namespace Sass {
         char* contents = static_cast<char*>(malloc(st.st_size + 2 * sizeof(char)));
         if (std::fread(static_cast<void*>(contents), 1, size, fd) != size) {
           free(contents);
+          std::fclose(fd);
           return nullptr;
         }
         if (std::fclose(fd) != 0) {
@@ -483,12 +493,11 @@ namespace Sass {
         contents[size] = '\0';
         contents[size + 1] = '\0';
       #endif
-      std::string extension;
+      sass::string extension;
       if (path.length() > 5) {
         extension = path.substr(path.length() - 5, 5);
       }
-      for(size_t i=0; i<extension.size();++i)
-        extension[i] = tolower(extension[i]);
+      Util::ascii_str_tolower(&extension);
       if (extension == ".sass" && contents != 0) {
         char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
         free(contents); // free the indented contents
@@ -499,21 +508,21 @@ namespace Sass {
     }
 
     // split a path string delimited by semicolons or colons (OS dependent)
-    std::vector<std::string> split_path_list(const char* str)
+    sass::vector<sass::string> split_path_list(const char* str)
     {
-      std::vector<std::string> paths;
+      sass::vector<sass::string> paths;
       if (str == NULL) return paths;
       // find delimiter via prelexer (return zero at end)
       const char* end = Prelexer::find_first<PATH_SEP>(str);
       // search until null delimiter
       while (end) {
         // add path from current position to delimiter
-        paths.push_back(std::string(str, end - str));
+        paths.push_back(sass::string(str, end - str));
         str = end + 1; // skip delimiter
         end = Prelexer::find_first<PATH_SEP>(str);
       }
       // add path from current position to end
-      paths.push_back(std::string(str));
+      paths.push_back(sass::string(str));
       // return back
       return paths;
     }

data/ext/libsass/src/file.hpp

@@ -1,6 +1,10 @@
 #ifndef SASS_FILE_H
 #define SASS_FILE_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include <string>
 #include <vector>
 
@@ -13,56 +17,56 @@ namespace Sass {
 
     // return the current directory
     // always with forward slashes
-    std::string get_cwd();
+    sass::string get_cwd();
 
     // test if path exists and is a file
-    bool file_exists(const std::string& file);
+    bool file_exists(const sass::string& file);
 
     // return if given path is absolute
     // works with *nix and windows paths
-    bool is_absolute_path(const std::string& path);
+    bool is_absolute_path(const sass::string& path);
 
     // return only the directory part of path
-    std::string dir_name(const std::string& path);
+    sass::string dir_name(const sass::string& path);
 
     // return only the filename part of path
-    std::string base_name(const std::string&);
+    sass::string base_name(const sass::string&);
 
     // do a locigal clean up of the path
     // no physical check on the filesystem
-    std::string make_canonical_path (std::string path);
+    sass::string make_canonical_path (sass::string path);
 
     // join two path segments cleanly together
     // but only if right side is not absolute yet
-    std::string join_paths(std::string root, std::string name);
+    sass::string join_paths(sass::string root, sass::string name);
 
     // if the relative path is outside of the cwd we want want to
     // show the absolute path in console messages
-    std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path);
+    sass::string path_for_console(const sass::string& rel_path, const sass::string& abs_path, const sass::string& orig_path);
 
     // create an absolute path by resolving relative paths with cwd
-    std::string rel2abs(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
+    sass::string rel2abs(const sass::string& path, const sass::string& base = ".", const sass::string& cwd = get_cwd());
 
     // create a path that is relative to the given base directory
     // path and base will first be resolved against cwd to make them absolute
-    std::string abs2rel(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
+    sass::string abs2rel(const sass::string& path, const sass::string& base = ".", const sass::string& cwd = get_cwd());
 
     // helper function to resolve a filename
     // searching without variations in all paths
-    std::string find_file(const std::string& file, struct Sass_Compiler* options);
-    std::string find_file(const std::string& file, const std::vector<std::string> paths);
+    sass::string find_file(const sass::string& file, struct Sass_Compiler* options);
+    sass::string find_file(const sass::string& file, const sass::vector<sass::string> paths);
 
     // helper function to resolve a include filename
     // this has the original resolve logic for sass include
-    std::string find_include(const std::string& file, const std::vector<std::string> paths);
+    sass::string find_include(const sass::string& file, const sass::vector<sass::string> paths);
 
     // split a path string delimited by semicolons or colons (OS dependent)
-    std::vector<std::string> split_path_list(const char* paths);
+    sass::vector<sass::string> split_path_list(const char* paths);
 
     // try to load the given filename
     // returned memory must be freed
     // will auto convert .sass files
-    char* read_file(const std::string& file);
+    char* read_file(const sass::string& file);
 
   }
 
@@ -70,14 +74,14 @@ namespace Sass {
   class Importer {
     public:
       // requested import path
-      std::string imp_path;
+      sass::string imp_path;
       // parent context path
-      std::string ctx_path;
+      sass::string ctx_path;
       // base derived from context path
       // this really just acts as a cache
-      std::string base_path;
+      sass::string base_path;
     public:
-      Importer(std::string imp_path, std::string ctx_path)
+      Importer(sass::string imp_path, sass::string ctx_path)
       : imp_path(File::make_canonical_path(imp_path)),
         ctx_path(File::make_canonical_path(ctx_path)),
         base_path(File::dir_name(ctx_path))
@@ -88,9 +92,9 @@ namespace Sass {
   class Include : public Importer {
     public:
       // resolved absolute path
-      std::string abs_path;
+      sass::string abs_path;
     public:
-      Include(const Importer& imp, std::string abs_path)
+      Include(const Importer& imp, sass::string abs_path)
       : Importer(imp), abs_path(abs_path)
       { }
   };
@@ -100,7 +104,7 @@ namespace Sass {
     public:
       // the file contents
       char* contents;
-      // conected sourcemap
+      // connected sourcemap
       char* srcmap;
     public:
       Resource(char* contents, char* srcmap)
@@ -108,23 +112,10 @@ namespace Sass {
       { }
   };
 
-  // parsed stylesheet from loaded resource
-  class StyleSheet : public Resource {
-    public:
-      // parsed root block
-      Block_Obj root;
-    public:
-      StyleSheet(const Resource& res, Block_Obj root)
-      : Resource(res), root(root)
-      { }
-  };
-
   namespace File {
 
-    static std::vector<std::string> defaultExtensions = { ".scss", ".sass", ".css" };
-
-    std::vector<Include> resolve_includes(const std::string& root, const std::string& file,
-      const std::vector<std::string>& exts = defaultExtensions);
+    sass::vector<Include> resolve_includes(const sass::string& root, const sass::string& file,
+      const sass::vector<sass::string>& exts = { ".scss", ".sass", ".css" });
 
   }