sassc 2.2.1 → 2.3.0

data/ext/libsass/src/sass_context.hpp

@@ -90,7 +90,7 @@ struct Sass_Context : Sass_Options
   char* error_file;
   size_t error_line;
   size_t error_column;
-  const char* error_src;
+  char* error_src;
 
   // report imported files
   char** included_files;
@@ -126,4 +126,4 @@ struct Sass_Compiler {
   Sass::Block_Obj root;
 };
 
-#endif
+#endif

data/ext/libsass/src/sass_functions.cpp

@@ -101,7 +101,7 @@ extern "C" {
   }
 
   // Creator for a single import entry returned by the custom importer inside the list
-  // We take ownership of the memory for source and srcmap (freed when context is destroyd)
+  // We take ownership of the memory for source and srcmap (freed when context is destroyed)
   Sass_Import_Entry ADDCALL sass_make_import(const char* imp_path, const char* abs_path, char* source, char* srcmap)
   {
     Sass_Import* v = (Sass_Import*) calloc(1, sizeof(Sass_Import));

data/ext/libsass/src/sass_values.cpp

@@ -6,7 +6,6 @@
 #include <cstring>
 #include "util.hpp"
 #include "eval.hpp"
-#include "values.hpp"
 #include "operators.hpp"
 #include "sass/values.h"
 #include "sass_values.hpp"

data/ext/libsass/src/stylesheet.cpp

@@ -0,0 +1,22 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "stylesheet.hpp"
+
+namespace Sass {
+
+  // Constructor
+  Sass::StyleSheet::StyleSheet(const Resource& res, Block_Obj root) :
+    Resource(res),
+    root(root)
+  {
+  }
+
+  StyleSheet::StyleSheet(const StyleSheet& sheet) :
+    Resource(sheet),
+    root(sheet.root)
+  {
+  }
+
+}

data/ext/libsass/src/stylesheet.hpp

@@ -0,0 +1,57 @@
+#ifndef SASS_STYLESHEET_H
+#define SASS_STYLESHEET_H
+
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include "ast_fwd_decl.hpp"
+#include "extender.hpp"
+#include "file.hpp"
+
+namespace Sass {
+
+  // parsed stylesheet from loaded resource
+  // this should be a `Module` for sass 4.0
+  class StyleSheet : public Resource {
+    public:
+
+      // The canonical URL for this module's source file. This may be `null`
+      // if the module was loaded from a string without a URL provided.
+      // Uri get url;
+
+      // Modules that this module uses.
+      // List<Module> get upstream;
+
+      // The module's variables.
+      // Map<String, Value> get variables;
+
+      // The module's functions. Implementations must ensure
+      // that each [Callable] is stored under its own name.
+      // Map<String, Callable> get functions;
+
+      // The module's mixins. Implementations must ensure that
+      // each [Callable] is stored under its own name.
+      // Map<String, Callable> get mixins;
+
+      // The extensions defined in this module, which is also able to update
+      // [css]'s style rules in-place based on downstream extensions.
+      // Extender extender;
+
+      // The module's CSS tree.
+      Block_Obj root;
+
+    public:
+
+      // default argument constructor
+      StyleSheet(const Resource& res, Block_Obj root);
+
+      // Copy constructor
+      StyleSheet(const StyleSheet& res);
+
+  };
+
+
+}
+
+#endif

data/ext/libsass/src/to_value.cpp

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

data/ext/libsass/src/to_value.hpp

@@ -36,7 +36,7 @@ namespace Sass {
     Value* operator()(Function*);
 
     // convert to string via `To_String`
-    Value* operator()(Selector_List*);
+    Value* operator()(SelectorList*);
     Value* operator()(Binary_Expression*);
 
   };

data/ext/libsass/src/units.cpp

@@ -1,5 +1,7 @@
 #include "sass.hpp"
+#include <map>
 #include <stdexcept>
+#include <algorithm>
 #include "units.hpp"
 #include "error_handling.hpp"
 
@@ -328,7 +330,7 @@ namespace Sass {
     // has the advantage that they will be pre-sorted
     std::map<std::string, int> exponents;
 
-    // initialize by summing up occurences in unit vectors
+    // initialize by summing up occurrences in unit vectors
     // this will already cancel out equivalent units (e.q. px/px)
     for (size_t i = 0; i < iL; i ++) exponents[numerators[i]] += 1;
     for (size_t n = 0; n < nL; n ++) exponents[denominators[n]] -= 1;
@@ -394,7 +396,7 @@ namespace Sass {
            denominators.size() == 0;
   }
 
-  // this does not cover all cases (multiple prefered units)
+  // this does not cover all cases (multiple preferred units)
   double Units::convert_factor(const Units& r) const
   {
 
@@ -465,7 +467,7 @@ namespace Sass {
       {
         // get and increment afterwards
         const std::string r_den = *(r_den_it);
-        // get possible converstion factor for units
+        // get possible conversion factor for units
         double conversion = conversion_factor(l_den, r_den);
         // skip incompatible denominator
         if (conversion == 0) {

data/ext/libsass/src/util.cpp

@@ -2,6 +2,7 @@
 #include "sass.h"
 #include "ast.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 #include "lexer.hpp"
 #include "prelexer.hpp"
 #include "constants.hpp"
@@ -26,8 +27,8 @@ namespace Sass {
     #endif
 
     // https://github.com/sass/sass/commit/4e3e1d5684cc29073a507578fc977434ff488c93
-    if (fmod(val, 1) - 0.5 > - std::pow(0.1, precision + 1)) return std::ceil(val);
-    else if (fmod(val, 1) - 0.5 > std::pow(0.1, precision)) return std::floor(val);
+    if (std::fmod(val, 1) - 0.5 > - std::pow(0.1, precision + 1)) return std::ceil(val);
+    else if (std::fmod(val, 1) - 0.5 > std::pow(0.1, precision)) return std::floor(val);
     // work around some compiler issue
     // cygwin has it not defined in std
     using namespace std;
@@ -289,7 +290,7 @@ namespace Sass {
 
         // parse as many sequence chars as possible
         // ToDo: Check if ruby aborts after possible max
-        while (i + len < L && s[i + len] && isxdigit(s[i + len])) ++ len;
+        while (i + len < L && s[i + len] && Util::ascii_isxdigit(static_cast<unsigned char>(s[i + len]))) ++ len;
 
         if (len > 1) {
 
@@ -375,7 +376,7 @@ namespace Sass {
 
         // parse as many sequence chars as possible
         // ToDo: Check if ruby aborts after possible max
-        while (i + len < L && s[i + len] && isxdigit(s[i + len])) ++ len;
+        while (i + len < L && s[i + len] && Util::ascii_isxdigit(static_cast<unsigned char>(s[i + len]))) ++ len;
 
         // hex string?
         if (keep_utf8_sequences) {
@@ -535,7 +536,7 @@ namespace Sass {
 
       Block_Obj b = r->block();
 
-      Selector_List* sl = Cast<Selector_List>(r->selector());
+      SelectorList* sl = r->selector();
       bool hasSelectors = sl ? sl->length() > 0 : false;
 
       if (!hasSelectors) {
@@ -625,11 +626,12 @@ namespace Sass {
       return false;
     }
 
-    bool isPrintable(Media_Block* m, Sass_Output_Style style)
+    bool isPrintable(CssMediaRule* m, Sass_Output_Style style)
     {
       if (m == nullptr) return false;
       Block_Obj b = m->block();
       if (b == nullptr) return false;
+      if (m->empty()) return false;
       for (size_t i = 0, L = b->length(); i < L; ++i) {
         Statement_Obj stm = b->at(i);
         if (Cast<Directive>(stm)) return true;
@@ -649,7 +651,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Media_Block* mb = Cast<Media_Block>(stm)) {
+        else if (CssMediaRule* mb = Cast<CssMediaRule>(stm)) {
           if (isPrintable(mb, style)) {
             return true;
           }
@@ -702,7 +704,7 @@ namespace Sass {
             return true;
           }
         }
-        else if (Media_Block* m = Cast<Media_Block>(stm)) {
+        else if (CssMediaRule * m = Cast<CssMediaRule>(stm)) {
           if (isPrintable(m, style)) {
             return true;
           }
@@ -717,9 +719,5 @@ namespace Sass {
       return false;
     }
 
-    bool isAscii(const char chr) {
-      return unsigned(chr) < 128;
-    }
-
   }
 }

data/ext/libsass/src/util.hpp

@@ -8,11 +8,11 @@
 #include "sass/base.h"
 #include "ast_fwd_decl.hpp"
 
+#include <cmath>
 #include <cstring>
 #include <vector>
 #include <string>
 #include <assert.h>
-#include <math.h>
 
 #define SASS_ASSERT(cond, msg) assert(cond && msg)
 
@@ -93,13 +93,12 @@ namespace Sass {
 
     bool isPrintable(Ruleset* r, Sass_Output_Style style = NESTED);
     bool isPrintable(Supports_Block* r, Sass_Output_Style style = NESTED);
-    bool isPrintable(Media_Block* r, Sass_Output_Style style = NESTED);
+    bool isPrintable(CssMediaRule* r, Sass_Output_Style style = NESTED);
     bool isPrintable(Comment* b, Sass_Output_Style style = NESTED);
     bool isPrintable(Block_Obj b, Sass_Output_Style style = NESTED);
     bool isPrintable(String_Constant* s, Sass_Output_Style style = NESTED);
     bool isPrintable(String_Quoted* s, Sass_Output_Style style = NESTED);
     bool isPrintable(Declaration* d, Sass_Output_Style style = NESTED);
-    bool isAscii(const char chr);
 
   }
 }

data/ext/libsass/src/util_string.cpp

@@ -1,75 +1,125 @@
 #include "util_string.hpp"
 
+#include <iostream>
 #include <algorithm>
 
 namespace Sass {
-namespace Util {
+  namespace Util {
 
-std::string rtrim(const std::string &str) {
-  std::string trimmed = str;
-  size_t pos_ws = trimmed.find_last_not_of(" \t\n\v\f\r");
-  if (pos_ws != std::string::npos) {
-    trimmed.erase(pos_ws + 1);
-  } else {
-    trimmed.clear();
-  }
-  return trimmed;
-}
+    // ##########################################################################
+    // Special case insensitive string matcher. We can optimize
+    // the more general compare case quite a bit by requiring
+    // consumers to obey some rules (lowercase and no space).
+    // - `literal` must only contain lower case ascii characters
+    // there is one edge case where this could give false positives
+    // test could contain a (non-ascii) char exactly 32 below literal
+    // ##########################################################################
+    bool equalsLiteral(const char* lit, const std::string& test) {
+      // Work directly on characters
+      const char* src = test.c_str();
+      // There is a small chance that the search string
+      // Is longer than the rest of the string to look at
+      while (*lit && (*src == *lit || *src + 32 == *lit)) {
+        ++src, ++lit;
+      }
+      // True if literal is at end
+      // If not test was too long
+      return *lit == 0;
+    }
 
-std::string normalize_newlines(const std::string& str) {
-  std::string result;
-  result.reserve(str.size());
-  std::size_t pos = 0;
-  while (true) {
-    const std::size_t newline = str.find_first_of("\n\f\r", pos);
-    if (newline == std::string::npos) break;
-    result.append(str, pos, newline - pos);
-    result += '\n';
-    if (str[newline] == '\r' && str[newline + 1] == '\n') {
-      pos = newline + 2;
-    } else {
-      pos = newline + 1;
+    void ascii_str_tolower(std::string* s) {
+      for (auto& ch : *s) {
+        ch = ascii_tolower(static_cast<unsigned char>(ch));
+      }
     }
-  }
-  result.append(str, pos, std::string::npos);
-  return result;
-}
 
-std::string normalize_underscores(const std::string& str) {
-  std::string normalized = str;
-  std::replace(normalized.begin(), normalized.end(), '_', '-');
-  return normalized;
-}
+    void ascii_str_toupper(std::string* s) {
+      for (auto& ch : *s) {
+        ch = ascii_toupper(static_cast<unsigned char>(ch));
+      }
+    }
 
-std::string normalize_decimals(const std::string& str) {
-  std::string normalized;
-  if (!str.empty() && str[0] == '.') {
-    normalized.reserve(str.size() + 1);
-    normalized += '0';
-    normalized += str;
-  } else {
-    normalized = str;
-  }
-  return normalized;
-}
+    std::string rtrim(std::string str) {
+      auto it = std::find_if_not(str.rbegin(), str.rend(), ascii_isspace);
+      str.erase(str.rend() - it);
+      return str;
+    }
 
-char opening_bracket_for(char closing_bracket) {
-  switch (closing_bracket) {
-    case ')': return '(';
-    case ']': return '[';
-    case '}': return '{';
-    default: return '\0';
-  }
-}
+    // ###########################################################################
+    // Returns [name] without a vendor prefix.
+    // If [name] has no vendor prefix, it's returned as-is.
+    // ###########################################################################
+    std::string unvendor(const std::string& name)
+    {
+      if (name.size() < 2) return name;
+      if (name[0] != '-') return name;
+      if (name[1] == '-') return name;
+      for (size_t i = 2; i < name.size(); i++) {
+        if (name[i] == '-') return name.substr(i + 1);
+      }
+      return name;
+    }
+    // EO unvendor
+
+    std::string normalize_newlines(const std::string& str) {
+      std::string result;
+      result.reserve(str.size());
+      std::size_t pos = 0;
+      while (true) {
+        const std::size_t newline = str.find_first_of("\n\f\r", pos);
+        if (newline == std::string::npos) break;
+        result.append(str, pos, newline - pos);
+        result += '\n';
+        if (str[newline] == '\r' && str[newline + 1] == '\n') {
+          pos = newline + 2;
+        }
+        else {
+          pos = newline + 1;
+        }
+      }
+      result.append(str, pos, std::string::npos);
+      return result;
+    }
+
+    std::string normalize_underscores(const std::string& str) {
+      std::string normalized = str;
+      std::replace(normalized.begin(), normalized.end(), '_', '-');
+      return normalized;
+    }
+
+    std::string normalize_decimals(const std::string& str) {
+      std::string normalized;
+      if (!str.empty() && str[0] == '.') {
+        normalized.reserve(str.size() + 1);
+        normalized += '0';
+        normalized += str;
+      }
+      else {
+        normalized = str;
+      }
+      return normalized;
+    }
+
+    char opening_bracket_for(char closing_bracket) {
+      switch (closing_bracket) {
+      case ')': return '(';
+      case ']': return '[';
+      case '}': return '{';
+      default: return '\0';
+      }
+    }
+
+    char closing_bracket_for(char opening_bracket) {
+      switch (opening_bracket) {
+      case '(': return ')';
+      case '[': return ']';
+      case '{': return '}';
+      default: return '\0';
+      }
+    }
 
-char closing_bracket_for(char opening_bracket) {
-  switch (opening_bracket) {
-    case '(': return ')';
-    case '[': return ']';
-    case '{': return '}';
-    default: return '\0';
   }
-}
+  // namespace Util
 
-}  // namespace Sass
-}  // namespace Util
+}
+// namespace Sass