sassc 1.8.3 → 1.8.4

data/ext/libsass/src/source_map.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <string>
 #include <sstream>
 #include <iostream>
@@ -16,7 +17,7 @@ namespace Sass {
 
   std::string SourceMap::render_srcmap(Context &ctx) {
 
-    const bool include_sources = ctx.c_options->source_map_contents;
+    const bool include_sources = ctx.c_options.source_map_contents;
     const std::vector<std::string> links = ctx.srcmap_links;
     const std::vector<Resource>& sources(ctx.resources);
 
@@ -159,12 +160,12 @@ namespace Sass {
     current_position += offset;
   }
 
-  void SourceMap::add_open_mapping(AST_Node* node)
+  void SourceMap::add_open_mapping(const AST_Node* node)
   {
     mappings.push_back(Mapping(node->pstate(), current_position));
   }
 
-  void SourceMap::add_close_mapping(AST_Node* node)
+  void SourceMap::add_close_mapping(const AST_Node* node)
   {
     mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));
   }

data/ext/libsass/src/source_map.hpp

@@ -28,8 +28,8 @@ namespace Sass {
     void prepend(const Offset& offset);
     void append(const OutputBuffer& out);
     void prepend(const OutputBuffer& out);
-    void add_open_mapping(AST_Node* node);
-    void add_close_mapping(AST_Node* node);
+    void add_open_mapping(const AST_Node* node);
+    void add_close_mapping(const AST_Node* node);
 
     std::string render_srcmap(Context &ctx);
     ParserState remap(const ParserState& pstate);

data/ext/libsass/src/subset_map.hpp

@@ -94,7 +94,6 @@ namespace Sass {
     { ss.insert(s[i]); }
     for (size_t i = 0, S = s.size(); i < S; ++i)
     {
-      hash_[s[i]];
       hash_[s[i]].push_back(make_triple(s, ss, index));
     }
   }

data/ext/libsass/src/to_c.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "to_c.hpp"
 #include "ast.hpp"
 

data/ext/libsass/src/to_c.hpp

@@ -8,15 +8,13 @@
 namespace Sass {
 
   class To_C : public Operation_CRTP<union Sass_Value*, To_C> {
-    // import all the class-specific methods and override as desired
-    using Operation<union Sass_Value*>::operator();
     // override this to define a catch-all
     union Sass_Value* fallback_impl(AST_Node* n);
 
   public:
 
     To_C() { }
-    virtual ~To_C() { }
+    ~To_C() { }
 
     union Sass_Value* operator()(Boolean*);
     union Sass_Value* operator()(Number*);

data/ext/libsass/src/to_value.cpp

@@ -1,6 +1,6 @@
+#include "sass.hpp"
 #include "ast.hpp"
 #include "to_value.hpp"
-#include "to_string.hpp"
 
 namespace Sass {
 
@@ -91,19 +91,17 @@ namespace Sass {
   // Selector_List is converted to a string
   Value* To_Value::operator()(Selector_List* s)
   {
-    To_String to_string(&ctx);
     return SASS_MEMORY_NEW(mem, String_Quoted,
                            s->pstate(),
-                           s->perform(&to_string));
+                           s->to_string(ctx.c_options));
   }
 
   // Binary_Expression is converted to a string
   Value* To_Value::operator()(Binary_Expression* s)
   {
-    To_String to_string(&ctx);
     return SASS_MEMORY_NEW(mem, String_Quoted,
                            s->pstate(),
-                           s->perform(&to_string));
+                           s->to_string(ctx.c_options));
   }
 
 };

data/ext/libsass/src/to_value.hpp

@@ -21,7 +21,7 @@ namespace Sass {
     To_Value(Context& ctx, Memory_Manager& mem)
     : ctx(ctx), mem(mem)
     { }
-    virtual ~To_Value() { }
+    ~To_Value() { }
     using Operation<Value*>::operator();
 
     Value* operator()(Argument*);

data/ext/libsass/src/units.cpp

@@ -1,10 +1,7 @@
+#include "sass.hpp"
 #include <stdexcept>
 #include "units.hpp"
 
-#ifdef IN
-#undef IN
-#endif
-
 namespace Sass {
 
   /* the conversion matrix can be readed the following way */
@@ -52,88 +49,128 @@ namespace Sass {
     /* dppx */ { 1/96.0,    2.54/96,   1        }
   };
 
-  SassUnitType get_unit_type(SassUnit unit)
+  UnitClass get_unit_type(UnitType unit)
+  {
+    switch (unit & 0xFF00)
+    {
+      case UnitClass::LENGTH:      return UnitClass::LENGTH; break;
+      case UnitClass::ANGLE:       return UnitClass::ANGLE; break;
+      case UnitClass::TIME:        return UnitClass::TIME; break;
+      case UnitClass::FREQUENCY:   return UnitClass::FREQUENCY; break;
+      case UnitClass::RESOLUTION:  return UnitClass::RESOLUTION; break;
+      default:                     return UnitClass::INCOMMENSURABLE; break;
+    }
+  };
+
+  std::string get_unit_class(UnitType unit)
   {
     switch (unit & 0xFF00)
     {
-      case SassUnitType::LENGTH:      return SassUnitType::LENGTH; break;
-      case SassUnitType::ANGLE:       return SassUnitType::ANGLE; break;
-      case SassUnitType::TIME:        return SassUnitType::TIME; break;
-      case SassUnitType::FREQUENCY:   return SassUnitType::FREQUENCY; break;
-      case SassUnitType::RESOLUTION:  return SassUnitType::RESOLUTION; break;
-      default:                        return SassUnitType::INCOMMENSURABLE; break;
+      case UnitClass::LENGTH:      return "LENGTH"; break;
+      case UnitClass::ANGLE:       return "ANGLE"; break;
+      case UnitClass::TIME:        return "TIME"; break;
+      case UnitClass::FREQUENCY:   return "FREQUENCY"; break;
+      case UnitClass::RESOLUTION:  return "RESOLUTION"; break;
+      default:                     return "INCOMMENSURABLE"; break;
     }
   };
 
-  SassUnit string_to_unit(const std::string& s)
+  UnitType string_to_unit(const std::string& s)
   {
     // size units
-    if      (s == "px")   return SassUnit::PX;
-    else if (s == "pt")   return SassUnit::PT;
-    else if (s == "pc")   return SassUnit::PC;
-    else if (s == "mm")   return SassUnit::MM;
-    else if (s == "cm")   return SassUnit::CM;
-    else if (s == "in")   return SassUnit::IN;
+    if      (s == "px")   return UnitType::PX;
+    else if (s == "pt")   return UnitType::PT;
+    else if (s == "pc")   return UnitType::PC;
+    else if (s == "mm")   return UnitType::MM;
+    else if (s == "cm")   return UnitType::CM;
+    else if (s == "in")   return UnitType::IN;
     // angle units
-    else if (s == "deg")  return SassUnit::DEG;
-    else if (s == "grad") return SassUnit::GRAD;
-    else if (s == "rad")  return SassUnit::RAD;
-    else if (s == "turn") return SassUnit::TURN;
+    else if (s == "deg")  return UnitType::DEG;
+    else if (s == "grad") return UnitType::GRAD;
+    else if (s == "rad")  return UnitType::RAD;
+    else if (s == "turn") return UnitType::TURN;
     // time units
-    else if (s == "s")    return SassUnit::SEC;
-    else if (s == "ms")   return SassUnit::MSEC;
+    else if (s == "s")    return UnitType::SEC;
+    else if (s == "ms")   return UnitType::MSEC;
     // frequency units
-    else if (s == "Hz")   return SassUnit::HERTZ;
-    else if (s == "kHz")  return SassUnit::KHERTZ;
+    else if (s == "Hz")   return UnitType::HERTZ;
+    else if (s == "kHz")  return UnitType::KHERTZ;
     // resolutions units
-    else if (s == "dpi")  return SassUnit::DPI;
-    else if (s == "dpcm") return SassUnit::DPCM;
-    else if (s == "dppx") return SassUnit::DPPX;
+    else if (s == "dpi")  return UnitType::DPI;
+    else if (s == "dpcm") return UnitType::DPCM;
+    else if (s == "dppx") return UnitType::DPPX;
     // for unknown units
-    else return SassUnit::UNKNOWN;
+    else return UnitType::UNKNOWN;
   }
 
-  const char* unit_to_string(SassUnit unit)
+  const char* unit_to_string(UnitType unit)
   {
     switch (unit) {
       // size units
-      case SassUnit::PX:      return "px"; break;
-      case SassUnit::PT:      return "pt"; break;
-      case SassUnit::PC:      return "pc"; break;
-      case SassUnit::MM:      return "mm"; break;
-      case SassUnit::CM:      return "cm"; break;
-      case SassUnit::IN:      return "in"; break;
+      case UnitType::PX:      return "px"; break;
+      case UnitType::PT:      return "pt"; break;
+      case UnitType::PC:      return "pc"; break;
+      case UnitType::MM:      return "mm"; break;
+      case UnitType::CM:      return "cm"; break;
+      case UnitType::IN:      return "in"; break;
       // angle units
-      case SassUnit::DEG:     return "deg"; break;
-      case SassUnit::GRAD:    return "grad"; break;
-      case SassUnit::RAD:     return "rad"; break;
-      case SassUnit::TURN:    return "turn"; break;
+      case UnitType::DEG:     return "deg"; break;
+      case UnitType::GRAD:    return "grad"; break;
+      case UnitType::RAD:     return "rad"; break;
+      case UnitType::TURN:    return "turn"; break;
       // time units
-      case SassUnit::SEC:     return "s"; break;
-      case SassUnit::MSEC:    return "ms"; break;
+      case UnitType::SEC:     return "s"; break;
+      case UnitType::MSEC:    return "ms"; break;
       // frequency units
-      case SassUnit::HERTZ:   return "Hz"; break;
-      case SassUnit::KHERTZ:  return "kHz"; break;
+      case UnitType::HERTZ:   return "Hz"; break;
+      case UnitType::KHERTZ:  return "kHz"; break;
       // resolutions units
-      case SassUnit::DPI:     return "dpi"; break;
-      case SassUnit::DPCM:    return "dpcm"; break;
-      case SassUnit::DPPX:    return "dppx"; break;
+      case UnitType::DPI:     return "dpi"; break;
+      case UnitType::DPCM:    return "dpcm"; break;
+      case UnitType::DPPX:    return "dppx"; break;
       // for unknown units
       default:                return ""; break;
     }
   }
 
+  std::string unit_to_class(const std::string& s)
+  {
+    if      (s == "px")   return "LENGTH";
+    else if (s == "pt")   return "LENGTH";
+    else if (s == "pc")   return "LENGTH";
+    else if (s == "mm")   return "LENGTH";
+    else if (s == "cm")   return "LENGTH";
+    else if (s == "in")   return "LENGTH";
+    // angle units
+    else if (s == "deg")  return "ANGLE";
+    else if (s == "grad") return "ANGLE";
+    else if (s == "rad")  return "ANGLE";
+    else if (s == "turn") return "ANGLE";
+    // time units
+    else if (s == "s")    return "TIME";
+    else if (s == "ms")   return "TIME";
+    // frequency units
+    else if (s == "Hz")   return "FREQUENCY";
+    else if (s == "kHz")  return "FREQUENCY";
+    // resolutions units
+    else if (s == "dpi")  return "RESOLUTION";
+    else if (s == "dpcm") return "RESOLUTION";
+    else if (s == "dppx") return "RESOLUTION";
+    // for unknown units
+    return "CUSTOM:" + s;
+  }
+
   // throws incompatibleUnits exceptions
   double conversion_factor(const std::string& s1, const std::string& s2, bool strict)
   {
     // assert for same units
     if (s1 == s2) return 1;
     // get unit enum from string
-    SassUnit u1 = string_to_unit(s1);
-    SassUnit u2 = string_to_unit(s2);
+    UnitType u1 = string_to_unit(s1);
+    UnitType u2 = string_to_unit(s2);
     // query unit group types
-    SassUnitType t1 = get_unit_type(u1);
-    SassUnitType t2 = get_unit_type(u2);
+    UnitClass t1 = get_unit_type(u1);
+    UnitClass t2 = get_unit_type(u2);
     // get absolute offset
     // used for array acces
     size_t i1 = u1 - t1;
@@ -144,17 +181,17 @@ namespace Sass {
     // only process known units
     if (u1 != UNKNOWN && u2 != UNKNOWN) {
       switch (t1) {
-        case SassUnitType::LENGTH:              return size_conversion_factors[i1][i2]; break;
-        case SassUnitType::ANGLE:             return angle_conversion_factors[i1][i2]; break;
-        case SassUnitType::TIME:              return time_conversion_factors[i1][i2]; break;
-        case SassUnitType::FREQUENCY:         return frequency_conversion_factors[i1][i2]; break;
-        case SassUnitType::RESOLUTION:        return resolution_conversion_factors[i1][i2]; break;
+        case UnitClass::LENGTH:            return size_conversion_factors[i1][i2]; break;
+        case UnitClass::ANGLE:             return angle_conversion_factors[i1][i2]; break;
+        case UnitClass::TIME:              return time_conversion_factors[i1][i2]; break;
+        case UnitClass::FREQUENCY:         return frequency_conversion_factors[i1][i2]; break;
+        case UnitClass::RESOLUTION:        return resolution_conversion_factors[i1][i2]; break;
         // ToDo: should we throw error here?
-        case SassUnitType::INCOMMENSURABLE:   return 0; break;
+        case UnitClass::INCOMMENSURABLE:   return 0; break;
       }
     }
     // fallback
-    return 1;
+    return 0;
   }
 
 }

data/ext/libsass/src/units.hpp

@@ -7,9 +7,9 @@
 
 namespace Sass {
 
-  const double PI = acos(-1);
+  const double PI = std::acos(-1);
 
-  enum SassUnitType {
+  enum UnitClass {
     LENGTH = 0x000,
     ANGLE = 0x100,
     TIME = 0x200,
@@ -18,10 +18,10 @@ namespace Sass {
     INCOMMENSURABLE = 0x500
   };
 
-  enum SassUnit {
+  enum UnitType {
 
     // size units
-    IN = SassUnitType::LENGTH,
+    IN = UnitClass::LENGTH,
     CM,
     PC,
     MM,
@@ -58,9 +58,11 @@ namespace Sass {
   extern const double frequency_conversion_factors[2][2];
   extern const double resolution_conversion_factors[3][3];
 
-  enum SassUnit string_to_unit(const std::string&);
-  const char* unit_to_string(SassUnit unit);
-  enum SassUnitType get_unit_type(SassUnit unit);
+  enum Sass::UnitType string_to_unit(const std::string&);
+  const char* unit_to_string(Sass::UnitType unit);
+  enum Sass::UnitClass get_unit_type(Sass::UnitType unit);
+  std::string get_unit_class(Sass::UnitType unit);
+  std::string unit_to_class(const std::string&);
   // throws incompatibleUnits exceptions
   double conversion_factor(const std::string&, const std::string&, bool = true);
 
@@ -68,7 +70,7 @@ namespace Sass {
   {
     public:
       const char* msg;
-      incompatibleUnits(SassUnit a, SassUnit b)
+      incompatibleUnits(Sass::UnitType a, Sass::UnitType b)
       : exception()
       {
         std::stringstream ss;

data/ext/libsass/src/utf8_string.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <string>
 #include <vector>
 #include <cstdlib>
@@ -68,6 +69,8 @@ namespace Sass {
       }
     }
 
+    #ifdef _WIN32
+
     // utf16 functions
     using std::wstring;
 
@@ -93,5 +96,7 @@ namespace Sass {
       return utf16;
     }
 
+    #endif
+
   }
 }

data/ext/libsass/src/util.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include "sass.h"
 #include "ast.hpp"
 #include "util.hpp"
@@ -16,21 +17,15 @@ namespace Sass {
       exit(EXIT_FAILURE);                 \
     } while (0)
 
-  double round(double val)
+  double round(double val, size_t precision)
   {
+    // 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);
     // work around some compiler issue
     // cygwin has it not defined in std
     using namespace std;
-
-    // This was later repatched in 3.4.20
-    // which is as yet unreleased.
-    // https://github.com/sass/sass/commit/4e3e1d5684cc29073a507578fc977434ff488c93
-    if (fmod(val, 1) - 0.5 > -0.00001) return std::ceil(val);
     return ::round(val);
-
-    // Use this version once sass-spec is at 3.4.20
-    // if (fmod(val, 1) - 0.5 > -0.00001) return ::round(val);
-    // return value > 0 ? std::ceil(val) : std::floor(val);
   }
 
   /* Sadly, sass_strdup is not portable. */
@@ -104,94 +99,6 @@ namespace Sass {
     return *array = arr;
   }
 
-  std::string string_eval_escapes(const std::string& s)
-  {
-
-    std::string out("");
-    bool esc = false;
-    for (size_t i = 0, L = s.length(); i < L; ++i) {
-      if(s[i] == '\\' && esc == false) {
-        esc = true;
-
-        // escape length
-        size_t len = 1;
-
-        // 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;
-
-        // hex string?
-        if (len > 1) {
-
-          // convert the extracted hex string to code point value
-          // ToDo: Maybe we could do this without creating a substring
-          uint32_t cp = strtol(s.substr (i + 1, len - 1).c_str(), NULL, 16);
-
-          if (cp == 0) cp = 0xFFFD;
-
-          // assert invalid code points
-          if (cp >= 1) {
-
-            // use a very simple approach to convert via utf8 lib
-            // maybe there is a more elegant way; maybe we shoud
-            // convert the whole output from string to a stream!?
-            // allocate memory for utf8 char and convert to utf8
-            unsigned char u[5] = {0,0,0,0,0}; utf8::append(cp, u);
-            for(size_t m = 0; u[m] && m < 5; m++) out.push_back(u[m]);
-
-            // skip some more chars?
-            i += len - 1; esc = false;
-            if (cp == 10) out += ' ';
-
-          }
-
-        }
-
-      }
-      else {
-        out += s[i];
-        esc = false;
-      }
-    }
-    return out;
-
-  }
-
-  // double escape every escape sequences
-  // escape unescaped quotes and backslashes
-  std::string string_escape(const std::string& str)
-  {
-    std::string out("");
-    for (auto i : str) {
-      // escape some characters
-      if (i == '"') out += '\\';
-      if (i == '\'') out += '\\';
-      if (i == '\\') out += '\\';
-      out += i;
-    }
-    return out;
-  }
-
-  // unescape every escape sequence
-  // only removes unescaped backslashes
-  std::string string_unescape(const std::string& str)
-  {
-    std::string out("");
-    bool esc = false;
-    for (auto i : str) {
-      if (esc || i != '\\') {
-        esc = false;
-        out += i;
-      } else {
-        esc = true;
-      }
-    }
-    // open escape sequence at end
-    // maybe it should thow an error
-    if (esc) { out += '\\'; }
-    return out;
-  }
-
   // read css string (handle multiline DELIM)
   std::string read_css_string(const std::string& str)
   {
@@ -215,28 +122,6 @@ namespace Sass {
     return out;
   }
 
-  // evacuate unescaped quoted
-  // leave everything else untouched
-  std::string evacuate_quotes(const std::string& str)
-  {
-    std::string out("");
-    bool esc = false;
-    for (auto i : str) {
-      if (!esc) {
-        // ignore next character
-        if (i == '\\') esc = true;
-        // evacuate unescaped quotes
-        else if (i == '"') out += '\\';
-        else if (i == '\'') out += '\\';
-      }
-      // get escaped char now
-      else { esc = false; }
-      // remove nothing
-      out += i;
-    }
-    return out;
-  }
-
   // double escape all escape sequences
   // keep unescaped quotes and backslashes
   std::string evacuate_escapes(const std::string& str)
@@ -321,38 +206,6 @@ namespace Sass {
     else return text;
   }
 
-   std::string normalize_wspace(const std::string& str)
-  {
-    bool ws = false;
-    bool esc = false;
-    std::string text = "";
-    for(const char& i : str) {
-      if (!esc && i == '\\') {
-        esc = true;
-        ws = false;
-        text += i;
-      } else if (esc) {
-        esc = false;
-        ws = false;
-        text += i;
-      } else if (
-        i == ' ' ||
-        i == '\r' ||
-        i == '\n' ||
-        i == '	'
-      ) {
-        // only add one space
-        if (!ws) text += ' ';
-        ws = true;
-      } else {
-        ws = false;
-        text += i;
-      }
-    }
-    if (esc) text += '\\';
-    return text;
-  }
-
   // find best quote_mark by detecting if the string contains any single
   // or double quotes. When a single quote is found, we not we want a double
   // quote as quote_mark. Otherwise we check if the string cotains any double
@@ -462,7 +315,7 @@ namespace Sass {
 
   }
 
-  std::string quote(const std::string& s, char q, bool keep_linefeed_whitespace)
+  std::string quote(const std::string& s, char q)
   {
 
     // autodetect with fallback to given quote
@@ -488,13 +341,27 @@ namespace Sass {
 
       int cp = utf8::next(it, end);
 
+      // in case of \r, check if the next in sequence
+      // is \n and then advance the iterator.
+      if (cp == '\r' && it < end && utf8::peek_next(it, end) == '\n') {
+        cp = utf8::next(it, end);
+      }
+
       if (cp == '\n') {
         quoted.push_back('\\');
         quoted.push_back('a');
         // we hope we can remove this flag once we figure out
         // why ruby sass has these different output behaviors
-        if (keep_linefeed_whitespace)
+        // gsub(/\n(?![a-fA-F0-9\s])/, "\\a").gsub("\n", "\\a ")
+        using namespace Prelexer;
+        if (alternatives <
+          Prelexer::char_range<'a', 'f'>,
+          Prelexer::char_range<'A', 'F'>,
+          Prelexer::char_range<'0', '9'>,
+          space
+        >(it) != NULL) {
           quoted.push_back(' ');
+        }
       } else if (cp < 127) {
         quoted.push_back((char) cp);
       } else {
@@ -615,7 +482,7 @@ namespace Sass {
           }
         } else if (Comment* c = dynamic_cast<Comment*>(stm)) {
           // keep for uncompressed
-          if (style != SASS_STYLE_COMPRESSED) {
+          if (style != COMPRESSED) {
             hasDeclarations = true;
           }
           // output style compressed
@@ -720,7 +587,7 @@ namespace Sass {
         else if (typeid(*stm) == typeid(Comment)) {
           Comment* c = (Comment*) stm;
           // keep for uncompressed
-          if (style != SASS_STYLE_COMPRESSED) {
+          if (style != COMPRESSED) {
             return true;
           }
           // output style compressed