Merge pull request sass#718 from mgreter/fix/color-token-ops

xzyfer · xzyfer · commit 92e19f154124 · 2014-12-17T11:34:59.000+11:00
Improve color token operations
diff --git a/ast.hpp b/ast.hpp
@@ -1171,11 +1171,12 @@ namespace Sass {
     ADD_PROPERTY(double, g);
     ADD_PROPERTY(double, b);
     ADD_PROPERTY(double, a);
+    ADD_PROPERTY(bool, sixtuplet);
     ADD_PROPERTY(string, disp);
     size_t hash_;
   public:
-    Color(string path, Position position, double r, double g, double b, double a = 1, const string disp = "")
-    : Expression(path, position), r_(r), g_(g), b_(b), a_(a), disp_(disp),
+    Color(string path, Position position, double r, double g, double b, double a = 1, bool sixtuplet = true, const string disp = "")
+    : Expression(path, position), r_(r), g_(g), b_(b), a_(a), sixtuplet_(sixtuplet), disp_(disp),
       hash_(0)
     { concrete_type(COLOR); }
     string type() { return "color"; }
diff --git a/eval.cpp b/eval.cpp
@@ -1,6 +1,7 @@
 #include "eval.hpp"
 #include "ast.hpp"
 #include "bind.hpp"
+#include "util.hpp"
 #include "to_string.hpp"
 #include "inspect.hpp"
 #include "to_c.hpp"
@@ -561,27 +562,35 @@ namespace Sass {
     Expression* result = 0;
     bool zero = !( t->value().substr(0, 1) == "." ||
                    t->value().substr(0, 2) == "-." );
+
+    const string& text = t->value();
+    size_t num_pos = text.find_first_not_of(" \n\r\t");
+    if (num_pos == string::npos) num_pos = text.length();
+    size_t unit_pos = text.find_first_not_of("-+0123456789.", num_pos);
+    if (unit_pos == string::npos) unit_pos = text.length();
+    const string& num = text.substr(num_pos, unit_pos - num_pos);
+
     switch (t->type())
     {
       case Textual::NUMBER:
         result = new (ctx.mem) Number(t->path(),
                                       t->position(),
-                                      atof(t->value().c_str()),
+                                      atof(num.c_str()),
                                       "",
                                       zero);
         break;
       case Textual::PERCENTAGE:
         result = new (ctx.mem) Number(t->path(),
                                       t->position(),
-                                      atof(t->value().c_str()),
+                                      atof(num.c_str()),
                                       "%",
                                       zero);
         break;
       case Textual::DIMENSION:
         result = new (ctx.mem) Number(t->path(),
                                       t->position(),
-                                      atof(t->value().c_str()),
-                                      Token(number(t->value().c_str())),
+                                      atof(num.c_str()),
+                                      Token(number(text.c_str())),
                                       zero);
         break;
       case Textual::HEX: {
@@ -595,7 +604,7 @@ namespace Sass {
                                        static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                        static_cast<double>(strtol(g.c_str(), NULL, 16)),
                                        static_cast<double>(strtol(b.c_str(), NULL, 16)),
-                                       1,
+                                       1, true,
                                        t->value());
         }
         else {
@@ -604,7 +613,7 @@ namespace Sass {
                                        static_cast<double>(strtol(string(2,hext[0]).c_str(), NULL, 16)),
                                        static_cast<double>(strtol(string(2,hext[1]).c_str(), NULL, 16)),
                                        static_cast<double>(strtol(string(2,hext[2]).c_str(), NULL, 16)),
-                                       1,
+                                       1, false,
                                        t->value());
         }
       } break;
@@ -938,11 +947,13 @@ namespace Sass {
       case Binary_Expression::DIV: {
         string sep(op == Binary_Expression::SUB ? "-" : "/");
         To_String to_string;
+        string color(r->sixtuplet() ? r->perform(&to_string) :
+                     Util::normalize_sixtuplet(r->perform(&to_string)));
         return new (ctx.mem) String_Constant(l->path(),
                                              l->position(),
                                              l->perform(&to_string)
                                              + sep
-                                             + r->perform(&to_string));
+                                             + color);
       } break;
       case Binary_Expression::MOD: {
         error("cannot divide a number by a color", r->path(), r->position());
@@ -992,27 +1003,30 @@ namespace Sass {
     Expression::Concrete_Type ltype = lhs->concrete_type();
     Expression::Concrete_Type rtype = rhs->concrete_type();
 
-    // TODO: currently SASS converts colors to standard form when adding to strings;
-    // when https://github.com/nex3/sass/issues/363 is added this can be removed to
-    // preserve the original value
-    if (ltype == Expression::COLOR) ((Sass::Color*)lhs)->disp("");
-    if (rtype == Expression::COLOR) ((Sass::Color*)rhs)->disp("");
-
     string lstr(lhs->perform(&to_string));
     string rstr(rhs->perform(&to_string));
+
+    bool l_str_quoted = ((Sass::String*)lhs) && ((Sass::String*)lhs)->needs_unquoting();
+    bool r_str_quoted = ((Sass::String*)rhs) && ((Sass::String*)rhs)->needs_unquoting();
+    bool l_str_color = ltype == Expression::STRING && ctx.names_to_colors.count(lstr) && !l_str_quoted;
+    bool r_str_color = rtype == Expression::STRING && ctx.names_to_colors.count(rstr) && !r_str_quoted;
+
     bool unquoted = false;
     if (ltype == Expression::STRING && lstr[0] != '"' && lstr[0] != '\'') unquoted = true;
-    if (ltype == Expression::STRING && !lhs->is_delayed() && ctx.names_to_colors.count(lstr) &&
-        rtype == Expression::STRING && !rhs->is_delayed() && ctx.names_to_colors.count(rstr)) {
+    if (l_str_color && r_str_color) {
       return op_colors(ctx, op, ctx.names_to_colors[lstr], ctx.names_to_colors[rstr]);
     }
-    else if (ltype == Expression::STRING && !lhs->is_delayed() && ctx.names_to_colors.count(lstr) &&
-             rtype == Expression::NUMBER) {
+    else if (l_str_color && rtype == Expression::COLOR) {
+      return op_colors(ctx, op, ctx.names_to_colors[lstr], rhs);
+    }
+    else if (l_str_color && rtype == Expression::NUMBER) {
       return op_color_number(ctx, op, ctx.names_to_colors[lstr], rhs);
     }
-    else if (ltype == Expression::NUMBER &&
-             rtype == Expression::STRING && !rhs->is_delayed() && ctx.names_to_colors.count(rstr)) {
-      return op_number_color(ctx, op, rhs, ctx.names_to_colors[rstr]);
+    else if (ltype == Expression::COLOR && r_str_color) {
+      return op_number_color(ctx, op, lhs, ctx.names_to_colors[rstr]);
+    }
+    else if (ltype == Expression::NUMBER && r_str_color) {
+      return op_number_color(ctx, op, lhs, ctx.names_to_colors[rstr]);
     }
     if (op == Binary_Expression::MUL) error("invalid operands for multiplication", lhs->path(), lhs->position());
     if (op == Binary_Expression::MOD) error("invalid operands for modulo", lhs->path(), lhs->position());
diff --git a/functions.cpp b/functions.cpp
@@ -734,8 +734,11 @@ namespace Sass {
     {
       To_String to_string;
       AST_Node* arg = env["$string"];
-      string str(unquote(arg->perform(&to_string)));
+      string org(arg->perform(&to_string));
+      string str(unquote(org));
       String_Constant* result = new (ctx.mem) String_Constant(path, position, str);
+      // remember if the string was quoted (color tokens)
+      if (org[0] != str[0]) result->needs_unquoting(true);
       result->is_delayed(true);
       return result;
     }
diff --git a/util.cpp b/util.cpp
@@ -21,6 +21,22 @@ namespace Sass {
       return normalized[0] == '.' ? normalized.insert(0, prefix) : normalized;
     }
 
+    // compress a color sixtuplet if possible
+    // input: "#CC9900" -> output: "#C90"
+    string normalize_sixtuplet(const string& col) {
+      if(
+        col.substr(1, 1) == col.substr(2, 1) &&
+        col.substr(3, 1) == col.substr(4, 1) &&
+        col.substr(5, 1) == col.substr(6, 1)
+      ) {
+        return string("#" + col.substr(1, 1)
+                          + col.substr(3, 1)
+                          + col.substr(5, 1));
+      } else {
+        return string(col);
+      }
+    }
+
     bool isPrintable(Ruleset* r) {
       if (r == NULL) {
         return false;
diff --git a/util.hpp b/util.hpp
@@ -11,6 +11,7 @@ namespace Sass {
 
     std::string normalize_underscores(const std::string& str);
     std::string normalize_decimals(const std::string& str);
+    std::string normalize_sixtuplet(const std::string& col);
 
     bool containsAnyPrintableStatements(Block* b);
 

Original file line number	Diff line number	Diff line change
`@@ -734,8 +734,11 @@ namespace Sass {`
`734`	`734`	`{`
`735`	`735`	`To_String to_string;`
`736`	`736`	`AST_Node* arg = env["$string"];`
`737`		`- string str(unquote(arg->perform(&to_string)));`
	`737`	`+ string org(arg->perform(&to_string));`
	`738`	`+ string str(unquote(org));`
`738`	`739`	`String_Constant* result = new (ctx.mem) String_Constant(path, position, str);`
	`740`	`+ // remember if the string was quoted (color tokens)`
	`741`	`+ if (org[0] != str[0]) result->needs_unquoting(true);`
`739`	`742`	`result->is_delayed(true);`
`740`	`743`	`return result;`
`741`	`744`	`}`