sassc 1.0.0 → 1.1.0

data/ext/libsass/functions.cpp

@@ -249,16 +249,16 @@ namespace Sass {
         h = s = 0; // achromatic
       }
       else {
-        if (l < 0.5) s = del / (2.0 * l);
-        else         s = del / (2.0 - 2.0 * l);
+        if (l < 0.5) s = del / (max + min);
+        else         s = del / (2.0 - max - min);
 
-        if      (r == max) h = 60 * (g - b) / del;
-        else if (g == max) h = 60 * (b - r) / del + 120;
-        else if (b == max) h = 60 * (r - g) / del + 240;
+        if      (r == max) h = (g - b) / del + (g < b ? 6 : 0);
+        else if (g == max) h = (b - r) / del + 2;
+        else if (b == max) h = (r - g) / del + 4;
       }
 
       HSL hsl_struct;
-      hsl_struct.h = h;
+      hsl_struct.h = h / 6 * 360;
       hsl_struct.s = s * 100;
       hsl_struct.l = l * 100;
 
@@ -281,11 +281,18 @@ namespace Sass {
       s /= 100.0;
       l /= 100.0;
 
+      if (l < 0) l = 0;
+      if (s < 0) s = 0;
+      if (l > 1) l = 1;
+      if (s > 1) s = 1;
+      while (h < 0) h += 1;
+      while (h > 1) h -= 1;
+
       // Algorithm from the CSS3 spec: http://www.w3.org/TR/css3-color/#hsl-color.
       double m2;
       if (l <= 0.5) m2 = l*(s+1.0);
       else m2 = (l+s)-(l*s);
-      double m1 = (l*2)-m2;
+      double m1 = (l*2.0)-m2;
       // round the results -- consider moving this into the Color constructor
       double r = (h_to_rgb(m1, m2, h+1.0/3.0) * 255.0);
       double g = (h_to_rgb(m1, m2, h) * 255.0);
@@ -760,15 +767,18 @@ namespace Sass {
     Signature unquote_sig = "unquote($string)";
     BUILT_IN(sass_unquote)
     {
-      To_String to_string(&ctx);
       AST_Node* arg = env["$string"];
-      if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
+      if (dynamic_cast<Null*>(arg)) {
+        return new (ctx.mem) Null(pstate);
+      }
+      else if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
         String_Constant* result = new (ctx.mem) String_Constant(pstate, string_quoted->value());
         // remember if the string was quoted (color tokens)
         result->sass_fix_1291(string_quoted->quote_mark() != 0);
         return result;
       }
-      return new (ctx.mem) String_Constant(pstate, string(arg->perform(&to_string)));
+      To_String to_string(&ctx);
+      return new (ctx.mem) String_Constant(pstate, unquote(string(arg->perform(&to_string))));
     }
 
     Signature quote_sig = "quote($string)";
@@ -906,28 +916,25 @@ namespace Sass {
       string newstr;
       try {
         String_Constant* s = ARG("$string", String_Constant);
-        Number* n = ARG("$start-at", Number);
-        Number* m = ARG("$end-at", Number);
+        double start_at = ARG("$start-at", Number)->value();
+        double end_at = ARG("$end-at", Number)->value();
 
         string str = unquote(s->value());
 
-        // normalize into 0-based indices
-        size_t start = UTF_8::offset_at_position(str, UTF_8::normalize_index(static_cast<int>(n->value()), UTF_8::code_point_count(str)));
-        size_t end = UTF_8::offset_at_position(str, UTF_8::normalize_index(static_cast<int>(m->value()), UTF_8::code_point_count(str)));
-
-        // `str-slice` should always return an empty string when $end-at == 0
-        // `normalize_index` normalizes 1 -> 0 so we need to check the original value
-        if(m->value() == 0) {
-          if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
-            if(!ss->quote_mark()) return new (ctx.mem) Null(pstate);
-          } else {
-            return new (ctx.mem) Null(pstate);
-          }
-          newstr = "";
-        } else if(start == end && m->value() != 0) {
-          newstr = str.substr(start, 1);
-        } else if(end > start) {
-          newstr = str.substr(start, end - start + UTF_8::code_point_size_at_offset(str, end));
+        size_t size = utf8::distance(str.begin(), str.end());
+        if (end_at <= size * -1.0) { end_at += size; }
+        if (end_at < 0) { end_at += size + 1; }
+        if (end_at > size) { end_at = size; }
+        if (start_at < 0) { start_at += size + 1; }
+        else if (start_at == 0) { ++ start_at; }
+
+        if (start_at <= end_at)
+        {
+          string::iterator start = str.begin();
+          utf8::advance(start, start_at - 1, str.end());
+          string::iterator end = start;
+          utf8::advance(end, end_at - start_at + 1, str.end());
+          newstr = string(start, end);
         }
         if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
           if(ss->quote_mark()) newstr = quote(newstr);
@@ -1244,13 +1251,6 @@ namespace Sass {
       return zippers;
     }
 
-    Signature compact_sig = "compact($values...)";
-    BUILT_IN(compact)
-    {
-      error("`compact` has been removed from libsass because it's not part of the Sass spec", pstate);
-      return 0; // suppress warning, error will exit anyway
-    }
-
     Signature list_separator_sig = "list_separator($list)";
     BUILT_IN(list_separator)
     {
@@ -1471,7 +1471,7 @@ namespace Sass {
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression* expr = arglist->value_at_index(i);
         if (arglist->is_arglist()) {
-           Argument* arg = static_cast<Argument*>(expr);
+          Argument* arg = static_cast<Argument*>((*arglist)[i]);
           *args << new (ctx.mem) Argument(pstate,
                                           expr,
                                           "",

data/ext/libsass/functions.hpp

@@ -78,7 +78,6 @@ namespace Sass {
     extern Signature join_sig;
     extern Signature append_sig;
     extern Signature zip_sig;
-    extern Signature compact_sig;
     extern Signature list_separator_sig;
     extern Signature type_of_sig;
     extern Signature unit_sig;
@@ -153,7 +152,6 @@ namespace Sass {
     BUILT_IN(join);
     BUILT_IN(append);
     BUILT_IN(zip);
-    BUILT_IN(compact);
     BUILT_IN(list_separator);
     BUILT_IN(type_of);
     BUILT_IN(unit);

data/ext/libsass/inspect.cpp

@@ -416,6 +416,7 @@ namespace Sass {
 
   void Inspect::operator()(Number* n)
   {
+    n->normalize();
     stringstream ss;
     ss.precision(ctx ? ctx->precision : 5);
     ss << fixed << n->value();
@@ -424,8 +425,11 @@ namespace Sass {
     // if after applying precsision, the value gets
     // truncated to zero, sass emits 0.0 instead of 0
     bool nonzero = n->value() != 0;
-    for (size_t i = d.length()-1; d[i] == '0'; --i) {
-      d.resize(d.length()-1);
+    size_t decimal = d.find('.');
+    if (decimal != string::npos) {
+      for (size_t i = d.length()-1; d[i] == '0' && i >= decimal; --i) {
+        d.resize(d.length()-1);
+      }
     }
     if (d[d.length()-1] == '.') d.resize(d.length()-1);
     if (n->numerator_units().size() > 1 ||
@@ -444,6 +448,9 @@ namespace Sass {
     // use fractional output if we had
     // a value before it got truncated
     if (d == "0" && nonzero) d = "0.0";
+    // if the precision is 0 sass cast
+    // casts to a float with precision 1
+    if (ctx->precision == 0) d += ".0";
     // append number and unit
     append_token(d + n->unit(), n);
   }

data/ext/libsass/output.cpp

@@ -8,8 +8,7 @@ namespace Sass {
   Output::Output(Context* ctx)
   : Inspect(Emitter(ctx)),
     charset(""),
-    top_imports(0),
-    top_comments(0)
+    top_nodes(0)
   {}
 
   Output::~Output() { }
@@ -21,7 +20,7 @@ namespace Sass {
 
   void Output::operator()(Import* imp)
   {
-    top_imports.push_back(imp);
+    top_nodes.push_back(imp);
   }
 
   OutputBuffer Output::get_buffer(void)
@@ -30,15 +29,9 @@ namespace Sass {
     Emitter emitter(ctx);
     Inspect inspect(emitter);
 
-    size_t size_com = top_comments.size();
-    for (size_t i = 0; i < size_com; i++) {
-      top_comments[i]->perform(&inspect);
-      inspect.append_mandatory_linefeed();
-    }
-
-    size_t size_imp = top_imports.size();
-    for (size_t i = 0; i < size_imp; i++) {
-      top_imports[i]->perform(&inspect);
+    size_t size_nodes = top_nodes.size();
+    for (size_t i = 0; i < size_nodes; i++) {
+      top_nodes[i]->perform(&inspect);
       inspect.append_mandatory_linefeed();
     }
 
@@ -79,8 +72,8 @@ namespace Sass {
     // if (indentation && txt == "/**/") return;
     bool important = c->is_important();
     if (output_style() != COMPRESSED || important) {
-      if (buffer().size() + top_imports.size() == 0) {
-        top_comments.push_back(c);
+      if (buffer().size() == 0) {
+        top_nodes.push_back(c);
       } else {
         in_comment = true;
         append_indentation();

data/ext/libsass/output.hpp

@@ -30,8 +30,7 @@ namespace Sass {
 
   protected:
     string charset;
-    vector<Import*> top_imports;
-    vector<Comment*> top_comments;
+    vector<AST_Node*> top_nodes;
 
   public:
     OutputBuffer get_buffer(void);

data/ext/libsass/parser.cpp

@@ -1396,7 +1396,8 @@ namespace Sass {
     Token str(lexed);
     --str.end;
     --position;
-    String_Constant* str_node = new (ctx.mem) String_Constant(pstate, str);
+
+    String_Constant* str_node = new (ctx.mem) String_Constant(pstate, str.time_wspace());
     // str_node->is_delayed(true);
     return str_node;
   }
@@ -1414,6 +1415,7 @@ namespace Sass {
     Token str(lexed);
     const char* i = str.begin;
     // see if there any interpolants
+    const char* q;
     const char* p = find_first_in_interval< exactly<hash_lbrace> >(str.begin, str.end);
     if (!p) {
       String_Constant* str_node = new (ctx.mem) String_Constant(pstate, normalize_wspace(string(str.begin, str.end)));
@@ -1423,8 +1425,16 @@ namespace Sass {
 
     String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < str.end) {
+      q = find_first_in_interval< alternatives< exactly<'"'>, exactly<'\''> > >(i, str.end);
       p = find_first_in_interval< exactly<hash_lbrace> >(i, str.end);
-      if (p) {
+      if (q && (!p || p > q)) {
+        if (i < q) {
+          (*schema) << new (ctx.mem) String_Constant(pstate, string(i, q)); // accumulate the preceding segment if it's nonempty
+        }
+        (*schema) << new (ctx.mem) String_Constant(pstate, string(q, q+1)); // capture the quote mark separately
+        i = q+1;
+      }
+      else if (p) {
         if (i < p) {
           (*schema) << new (ctx.mem) String_Constant(pstate, string(i, p)); // accumulate the preceding segment if it's nonempty
         }
@@ -1498,7 +1508,7 @@ namespace Sass {
         (*schema) << new (ctx.mem) Textual(pstate, Textual::HEX, unquote(lexed));
       }
       else if (lex< quoted_string >()) {
-        (*schema) << new (ctx.mem) String_Constant(pstate, lexed);
+        (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
       }
       else if (lex< variable >()) {
         (*schema) << new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed));
@@ -1609,8 +1619,10 @@ namespace Sass {
   {
     lex< identifier >();
     string name(lexed);
+
+    ParserState call_pos = pstate;
     Arguments* args = parse_arguments(name == "url");
-    return new (ctx.mem) Function_Call(pstate, name, args);
+    return new (ctx.mem) Function_Call(call_pos, name, args);
   }
 
   Function_Call_Schema* Parser::parse_function_call_schema()

data/ext/libsass/position.hpp

@@ -89,6 +89,11 @@ namespace Sass {
     size_t length()    const { return end - begin; }
     string ws_before() const { return string(prefix, begin); }
     string to_string() const { return string(begin, end); }
+    string time_wspace() const {
+      string str(to_string());
+      string whitespaces(" \t\f\v\n\r");
+      return str.erase(str.find_last_not_of(whitespaces)+1);
+    }
 
     operator bool()   { return begin && end && begin >= end; }
     operator string() { return to_string(); }

data/ext/libsass/prelexer.cpp

@@ -710,7 +710,10 @@ namespace Sass {
     }
 
     const char* static_value(const char* src) {
-      return sequence< static_component,
+      return sequence< sequence<
+                         static_component,
+                         zero_plus< identifier >
+                       >,
                        zero_plus < sequence<
                                    alternatives<
                                      sequence< optional_spaces, alternatives<
@@ -722,6 +725,7 @@ namespace Sass {
                                    >,
                                    static_component
                        > >,
+                       optional_css_whitespace,
                        alternatives< exactly<';'>, exactly<'}'> >
                       >(src);
     }

data/ext/libsass/sass_values.cpp

@@ -38,6 +38,7 @@ extern "C" {
 
   struct Sass_String {
     enum Sass_Tag tag;
+    bool          quoted;
     char*         value;
   };
 
@@ -110,6 +111,8 @@ extern "C" {
   // Getters and setters for Sass_String
   const char* ADDCALL sass_string_get_value(const union Sass_Value* v) { return v->string.value; }
   void ADDCALL sass_string_set_value(union Sass_Value* v, char* value) { v->string.value = value; }
+  const bool ADDCALL sass_string_is_quoted(const union Sass_Value* v) { return v->string.quoted; }
+  void ADDCALL sass_string_set_quoted(union Sass_Value* v, bool quoted) { v->string.quoted = quoted; }
 
   // Getters and setters for Sass_Boolean
   bool ADDCALL sass_boolean_get_value(const union Sass_Value* v) { return v->boolean.value; }
@@ -187,6 +190,18 @@ extern "C" {
   {
     Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
+    v->string.quoted = false;
+    v->string.tag = SASS_STRING;
+    v->string.value = val ? sass_strdup(val) : 0;
+    if (v->string.value == 0) { free(v); return 0; }
+    return v;
+  }
+
+  union Sass_Value* ADDCALL sass_make_qstring(const char* val)
+  {
+    Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
+    if (v == 0) return 0;
+    v->string.quoted = true;
     v->string.tag = SASS_STRING;
     v->string.value = val ? sass_strdup(val) : 0;
     if (v->string.value == 0) { free(v); return 0; }

data/ext/libsass/sass_values.h

@@ -57,6 +57,8 @@ ADDAPI void ADDCALL sass_number_set_unit (union Sass_Value* v, char* unit);
 // Getters and setters for Sass_String
 ADDAPI const char* ADDCALL sass_string_get_value (const union Sass_Value* v);
 ADDAPI void ADDCALL sass_string_set_value (union Sass_Value* v, char* value);
+ADDAPI const bool ADDCALL sass_string_is_quoted(const union Sass_Value* v);
+ADDAPI void ADDCALL sass_string_set_quoted(union Sass_Value* v, bool quoted);
 
 // Getters and setters for Sass_Boolean
 ADDAPI bool ADDCALL sass_boolean_get_value (const union Sass_Value* v);
@@ -101,6 +103,7 @@ ADDAPI void ADDCALL sass_warning_set_message (union Sass_Value* v, char* msg);
 ADDAPI union Sass_Value* ADDCALL sass_make_null    (void);
 ADDAPI union Sass_Value* ADDCALL sass_make_boolean (bool val);
 ADDAPI union Sass_Value* ADDCALL sass_make_string  (const char* val);
+ADDAPI union Sass_Value* ADDCALL sass_make_qstring (const char* val);
 ADDAPI union Sass_Value* ADDCALL sass_make_number  (double val, const char* unit);
 ADDAPI union Sass_Value* ADDCALL sass_make_color   (double r, double g, double b, double a);
 ADDAPI union Sass_Value* ADDCALL sass_make_list    (size_t len, enum Sass_Separator sep);

data/ext/libsass/util.cpp

@@ -44,6 +44,59 @@ namespace Sass {
     return atof(str);
   }
 
+  string string_eval_escapes(const string& s)
+  {
+
+    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(), nullptr, 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
   string string_escape(const string& str)
@@ -177,6 +230,7 @@ namespace Sass {
   {
     string str = "";
     size_t has = 0;
+    char prev = 0;
     bool clean = false;
     for (auto i : text) {
       if (clean) {
@@ -188,7 +242,8 @@ namespace Sass {
         else {
           clean = false;
           str += ' ';
-          str += i;
+          if (prev == '*' && i == '/') str += "*/";
+          else str += i;
         }
       } else if (i == '\n') {
         clean = true;
@@ -197,6 +252,7 @@ namespace Sass {
       } else {
         str += i;
       }
+      prev = i;
     }
     if (has) return str;
     else return text;
@@ -327,12 +383,12 @@ namespace Sass {
       }
       // check for unexpected delimiter
       // be strict and throw error back
-      else if (!skipped && q == s[i]) {
-        // don't be that strict
-        return s;
-        // this basically always means an internal error and not users fault
-        error("Unescaped delimiter in string to unquote found. [" + s + "]", ParserState("[UNQUOTE]"));
-      }
+      // else if (!skipped && q == s[i]) {
+      //   // don't be that strict
+      //   return s;
+      //   // this basically always means an internal error and not users fault
+      //   error("Unescaped delimiter in string to unquote found. [" + s + "]", ParserState("[UNQUOTE]"));
+      // }
       else {
         skipped = false;
         unq.push_back(s[i]);