sassc 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d99b651f166586b10487e114cbe57530cf41072
-  data.tar.gz: e8d4530c45f6aac6d2f8f4b6a8b596e459c2a150
+  metadata.gz: cba905c4a611564a30f673941af311b360e64f79
+  data.tar.gz: 83bfb6df3c6ebb5e086badf0a950ebc839cbc6f7
 SHA512:
-  metadata.gz: 488fc5c6270fbdc0e86f3a6639e3a64ace06c9497eb0f56f545d014c6bb26135ffae85cfcb5abdbc94bdf8dae067f51e826e66e381a871529c32b1dfb78ca1d2
-  data.tar.gz: 68bb498e92248b581a9eeffc90d9fc661712ab504bb547cf562a52376d545f4bbbf0323cd1d5ee84c43e753aaeafc15697c26f325fe5958815f5d69096899dd3
+  metadata.gz: bd8dbb02e65de541608e51da7738824d1de7a8db2429d4b05396173a861ec2bbcd4d191ab39b426427b7ed5f31bcacf94a22782295827d736b1c0c1e8bd44212
+  data.tar.gz: e6c839d26054ff6bba74ab525e357f3161a25416748baacc0a2abd416ad21d0a9dafeb6d8d038e8a929d08eac12e28a53d109b0a2aaa4e4902b89abd715be1ac

data/README.md

@@ -6,7 +6,7 @@ This gem combines the speed of `libsass`, the [Sass C implementation](https://gi
 
 ### libsass Version
 
-[3.2.0-beta.6](https://github.com/sass/libsass/releases/tag/3.2.0-beta.6)
+[3.2.2](https://github.com/sass/libsass/releases/tag/3.2.2)
 
 ## Usage
 

data/ext/libsass/Readme.md

@@ -7,7 +7,7 @@ by Aaron Leung ([@akhleung]) and Hampton Catlin ([@hcatlin])
 [![Windows CI](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/sass/libsass/branch/master)
 [![Bountysource](https://www.bountysource.com/badge/tracker?tracker_id=283068)](https://www.bountysource.com/trackers/283068-libsass?utm_source=283068&utm_medium=shield&utm_campaign=TRACKER_BADGE)
 [![Coverage Status](https://img.shields.io/coveralls/sass/libsass.svg)](https://coveralls.io/r/sass/libsass?branch=feature%2Ftest-travis-ci-3)
-[![Join us](https://still-ridge-9421.herokuapp.com/badge.svg)](https://still-ridge-9421.herokuapp.com/)
+[![Join us](https://libsass-slack.herokuapp.com/badge.svg)](https://libsass-slack.herokuapp.com/)
 
 https://github.com/sass/libsass
 

data/ext/libsass/ast.cpp

@@ -589,6 +589,270 @@ namespace Sass {
     return result;
   }*/
 
+  Number::Number(ParserState pstate, double val, string u, bool zero)
+  : Expression(pstate),
+    value_(val),
+    zero_(zero),
+    numerator_units_(vector<string>()),
+    denominator_units_(vector<string>()),
+    hash_(0)
+  {
+    size_t l = 0, r = 0;
+    if (!u.empty()) {
+      bool nominator = true;
+      while (true) {
+        r = u.find_first_of("*/", l);
+        string unit(u.substr(l, r - l));
+        if (nominator) numerator_units_.push_back(unit);
+        else denominator_units_.push_back(unit);
+        if (u[r] == '/') nominator = false;
+        if (r == string::npos) break;
+        else l = r + 1;
+      }
+    }
+    concrete_type(NUMBER);
+  }
+
+  string Number::unit() const
+  {
+    stringstream u;
+    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
+      if (i) u << '*';
+      u << numerator_units_[i];
+    }
+    if (!denominator_units_.empty()) u << '/';
+    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
+      if (i) u << '*';
+      u << denominator_units_[i];
+    }
+    return u.str();
+  }
+
+  bool Number::is_unitless()
+  { return numerator_units_.empty() && denominator_units_.empty(); }
+
+  void Number::normalize(const string& prefered)
+  {
+
+    // first make sure same units cancel each other out
+    // it seems that a map table will fit nicely to do this
+    // we basically construct exponents for each unit
+    // has the advantage that they will be pre-sorted
+    map<string, int> exponents;
+
+    // initialize by summing up occurences in unit vectors
+    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) ++ exponents[numerator_units_[i]];
+    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) -- exponents[denominator_units_[i]];
+
+    // the final conversion factor
+    double factor = 1;
+
+    // get the first entry of numerators
+    // forward it when entry is converted
+    vector<string>::iterator nom_it = numerator_units_.begin();
+    vector<string>::iterator nom_end = numerator_units_.end();
+    vector<string>::iterator denom_it = denominator_units_.begin();
+    vector<string>::iterator denom_end = denominator_units_.end();
+
+    // main normalization loop
+    // should be close to optimal
+    while (denom_it != denom_end)
+    {
+      // get and increment afterwards
+      const string denom = *(denom_it ++);
+      // skip already canceled out unit
+      if (exponents[denom] >= 0) continue;
+      // skip all units we don't know how to convert
+      if (string_to_unit(denom) == INCOMMENSURABLE) continue;
+      // now search for nominator
+      while (nom_it != nom_end)
+      {
+        // get and increment afterwards
+        const string nom = *(nom_it ++);
+        // skip already canceled out unit
+        if (exponents[nom] <= 0) continue;
+        // skip all units we don't know how to convert
+        if (string_to_unit(nom) == INCOMMENSURABLE) continue;
+        // we now have two convertable units
+        // add factor for current conversion
+        factor *= conversion_factor(nom, denom);
+        // update nominator/denominator exponent
+        -- exponents[nom]; ++ exponents[denom];
+        // inner loop done
+        break;
+      }
+    }
+
+    // now we can build up the new unit arrays
+    numerator_units_.clear();
+    denominator_units_.clear();
+
+    // build them by iterating over the exponents
+    for (auto exp : exponents)
+    {
+      // maybe there is more effecient way to push
+      // the same item multiple times to a vector?
+      for(size_t i = 0, S = abs(exp.second); i < S; ++i)
+      {
+        // opted to have these switches in the inner loop
+        // makes it more readable and should not cost much
+        if (exp.second < 0) denominator_units_.push_back(exp.first);
+        else if (exp.second > 0) numerator_units_.push_back(exp.first);
+      }
+    }
+
+    // apply factor to value_
+    // best precision this way
+    value_ *= factor;
+
+    // maybe convert to other unit
+    // easier implemented on its own
+    convert(prefered);
+
+  }
+
+  void Number::convert(const string& prefered)
+  {
+    // abort if unit is empty
+    if (prefered.empty()) return;
+
+    // first make sure same units cancel each other out
+    // it seems that a map table will fit nicely to do this
+    // we basically construct exponents for each unit
+    // has the advantage that they will be pre-sorted
+    map<string, int> exponents;
+
+    // initialize by summing up occurences in unit vectors
+    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) ++ exponents[numerator_units_[i]];
+    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) -- exponents[denominator_units_[i]];
+
+    // the final conversion factor
+    double factor = 1;
+
+    vector<string>::iterator denom_it = denominator_units_.begin();
+    vector<string>::iterator denom_end = denominator_units_.end();
+
+    // main normalization loop
+    // should be close to optimal
+    while (denom_it != denom_end)
+    {
+      // get and increment afterwards
+      const string denom = *(denom_it ++);
+      // check if conversion is needed
+      if (denom == prefered) continue;
+      // skip already canceled out unit
+      if (exponents[denom] >= 0) continue;
+      // skip all units we don't know how to convert
+      if (string_to_unit(denom) == INCOMMENSURABLE) continue;
+      // we now have two convertable units
+      // add factor for current conversion
+      factor *= conversion_factor(denom, prefered);
+      // update nominator/denominator exponent
+      ++ exponents[denom]; -- exponents[prefered];
+    }
+
+    vector<string>::iterator nom_it = numerator_units_.begin();
+    vector<string>::iterator nom_end = numerator_units_.end();
+
+    // now search for nominator
+    while (nom_it != nom_end)
+    {
+      // get and increment afterwards
+      const string nom = *(nom_it ++);
+      // check if conversion is needed
+      if (nom == prefered) continue;
+      // skip already canceled out unit
+      if (exponents[nom] <= 0) continue;
+      // skip all units we don't know how to convert
+      if (string_to_unit(nom) == INCOMMENSURABLE) continue;
+      // we now have two convertable units
+      // add factor for current conversion
+      factor *= conversion_factor(nom, prefered);
+      // update nominator/denominator exponent
+      -- exponents[nom]; ++ exponents[prefered];
+    }
+
+    // now we can build up the new unit arrays
+    numerator_units_.clear();
+    denominator_units_.clear();
+
+    // build them by iterating over the exponents
+    for (auto exp : exponents)
+    {
+      // maybe there is more effecient way to push
+      // the same item multiple times to a vector?
+      for(size_t i = 0, S = abs(exp.second); i < S; ++i)
+      {
+        // opted to have these switches in the inner loop
+        // makes it more readable and should not cost much
+        if (exp.second < 0) denominator_units_.push_back(exp.first);
+        else if (exp.second > 0) numerator_units_.push_back(exp.first);
+      }
+    }
+
+    // apply factor to value_
+    // best precision this way
+    value_ *= factor;
+
+  }
+
+  // useful for making one number compatible with another
+  string Number::find_convertible_unit() const
+  {
+    for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
+      string u(numerator_units_[i]);
+      if (string_to_unit(u) != INCOMMENSURABLE) return u;
+    }
+    for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
+      string u(denominator_units_[i]);
+      if (string_to_unit(u) != INCOMMENSURABLE) return u;
+    }
+    return string();
+  }
+
+
+  bool Number::operator== (Expression* rhs) const
+  {
+    try
+    {
+      Number l(pstate_, value_, unit());
+      Number& r = dynamic_cast<Number&>(*rhs);
+      l.normalize(find_convertible_unit());
+      r.normalize(find_convertible_unit());
+      return l.unit() == r.unit() &&
+             l.value() == r.value();
+    }
+    catch (std::bad_cast&) {}
+    catch (...) { throw; }
+    return false;
+  }
+
+  bool Number::operator== (Expression& rhs) const
+  {
+    return operator==(&rhs);
+  }
+
+  bool List::operator==(Expression* rhs) const
+  {
+    try
+    {
+      List* r = dynamic_cast<List*>(rhs);
+      if (!r || length() != r->length()) return false;
+      if (separator() != r->separator()) return false;
+      for (size_t i = 0, L = r->length(); i < L; ++i)
+        if (*elements()[i] != *(*r)[i]) return false;
+      return true;
+    }
+    catch (std::bad_cast&) {}
+    catch (...) { throw; }
+    return false;
+  }
+
+  bool List::operator== (Expression& rhs) const
+  {
+    return operator==(&rhs);
+  }
+
   Expression* Hashed::at(Expression* k) const
   {
     if (elements_.count(k))

data/ext/libsass/ast.hpp

@@ -113,6 +113,7 @@ namespace Sass {
     static string type_name() { return ""; }
     virtual bool is_false() { return false; }
     virtual bool operator==( Expression& rhs) const { return false; }
+    virtual void set_delayed(bool delayed) { is_delayed(delayed); }
     virtual size_t hash() { return 0; }
   };
 }
@@ -756,23 +757,8 @@ namespace Sass {
     bool is_invisible() { return !length(); }
     Expression* value_at_index(size_t i);
 
-    virtual bool operator==(Expression& rhs) const
-    {
-      try
-      {
-        List& l = dynamic_cast<List&>(rhs);
-        if (!(l && length() == l.length() && separator() == l.separator())) return false;
-        for (size_t i = 0, L = l.length(); i < L; ++i)
-          if (!(*(elements()[i]) == *(l[i]))) return false;
-        return true;
-      }
-      catch (std::bad_cast&)
-      {
-        return false;
-      }
-      catch (...) { throw; }
-
-    }
+    virtual bool operator==(Expression& rhs) const;
+    virtual bool operator==(Expression* rhs) const;
 
     virtual size_t hash()
     {
@@ -786,6 +772,13 @@ namespace Sass {
       return hash_;
     }
 
+    virtual void set_delayed(bool delayed)
+    {
+      for (size_t i = 0, L = length(); i < L; ++i)
+        (elements()[i])->set_delayed(delayed);
+      is_delayed(delayed);
+    }
+
     ATTACH_OPERATIONS();
   };
 
@@ -857,6 +850,31 @@ namespace Sass {
                       Type t, Expression* lhs, Expression* rhs)
     : Expression(pstate), type_(t), left_(lhs), right_(rhs), hash_(0)
     { }
+    const string type_name() {
+      switch (type_) {
+        case AND: return "and"; break;
+        case OR: return "or"; break;
+        case EQ: return "eq"; break;
+        case NEQ: return "neq"; break;
+        case GT: return "gt"; break;
+        case GTE: return "gte"; break;
+        case LT: return "lt"; break;
+        case LTE: return "lte"; break;
+        case ADD: return "add"; break;
+        case SUB: return "sub"; break;
+        case MUL: return "mul"; break;
+        case DIV: return "div"; break;
+        case MOD: return "mod"; break;
+        case NUM_OPS: return "num_ops"; break;
+        default: return "invalid"; break;
+      }
+    }
+    virtual void set_delayed(bool delayed)
+    {
+      right()->set_delayed(delayed);
+      left()->set_delayed(delayed);
+      is_delayed(delayed);
+    }
     virtual bool operator==(Expression& rhs) const
     {
       try
@@ -896,6 +914,14 @@ namespace Sass {
     Unary_Expression(ParserState pstate, Type t, Expression* o)
     : Expression(pstate), type_(t), operand_(o), hash_(0)
     { }
+    const string type_name() {
+      switch (type_) {
+        case PLUS: return "plus"; break;
+        case MINUS: return "minus"; break;
+        case NOT: return "not"; break;
+        default: return "invalid"; break;
+      }
+    }
     virtual bool operator==(Expression& rhs) const
     {
       try
@@ -1161,129 +1187,22 @@ namespace Sass {
     vector<string> denominator_units_;
     size_t hash_;
   public:
-    Number(ParserState pstate, double val, string u = "", bool zero = true)
-    : Expression(pstate),
-      value_(val),
-      zero_(zero),
-      numerator_units_(vector<string>()),
-      denominator_units_(vector<string>()),
-      hash_(0)
-    {
-      if (!u.empty()) numerator_units_.push_back(u);
-      concrete_type(NUMBER);
-    }
+    Number(ParserState pstate, double val, string u = "", bool zero = true);
     bool            zero()              { return zero_; }
     vector<string>& numerator_units()   { return numerator_units_; }
     vector<string>& denominator_units() { return denominator_units_; }
     string type() { return "number"; }
     static string type_name() { return "number"; }
-    string unit() const
-    {
-      stringstream u;
-      for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-        if (i) u << '*';
-        u << numerator_units_[i];
-      }
-      if (!denominator_units_.empty()) u << '/';
-      for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-        if (i) u << '*';
-        u << denominator_units_[i];
-      }
-      return u.str();
-    }
-    bool is_unitless()
-    { return numerator_units_.empty() && denominator_units_.empty(); }
-    void normalize(string to = "")
-    {
-      // (multiple passes because I'm too tired to think up something clever)
-      // Find a unit to convert everything to, if one isn't provided.
-      if (to.empty()) {
-        for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-          string u(numerator_units_[i]);
-          if (string_to_unit(u) == INCOMMENSURABLE) {
-            continue;
-          }
-          else {
-            to = u;
-            break;
-          }
-        }
-      }
-      if (to.empty()) {
-        for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-          string u(denominator_units_[i]);
-          if (string_to_unit(u) == INCOMMENSURABLE) {
-            continue;
-          }
-          else {
-            to = u;
-            break;
-          }
-        }
-      }
-      // Now loop through again and do all the conversions.
-      for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-        string from(numerator_units_[i]);
-        if (string_to_unit(from) == INCOMMENSURABLE) continue;
-        value_ *= conversion_factor(from, to);
-        numerator_units_[i] = to;
-      }
-      for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-        string from(denominator_units_[i]);
-        if (string_to_unit(from) == INCOMMENSURABLE) continue;
-        value_ /= conversion_factor(from, to);
-        denominator_units_[i] = to;
-      }
-      // Now divide out identical units in the numerator and denominator.
-      vector<string> ncopy;
-      ncopy.reserve(numerator_units_.size());
-      for (vector<string>::iterator n = numerator_units_.begin();
-           n != numerator_units_.end();
-           ++n) {
-        vector<string>::iterator d = find(denominator_units_.begin(),
-                                          denominator_units_.end(),
-                                          *n);
-        if (d != denominator_units_.end()) {
-          denominator_units_.erase(d);
-        }
-        else {
-          ncopy.push_back(*n);
-        }
-      }
-      numerator_units_ = ncopy;
-      // Sort the units to make them pretty and, well, normal.
-      sort(numerator_units_.begin(), numerator_units_.end());
-      sort(denominator_units_.begin(), denominator_units_.end());
-    }
+    string unit() const;
+
+    bool is_unitless();
+    void convert(const string& unit = "");
+    void normalize(const string& unit = "");
     // useful for making one number compatible with another
-    string find_convertible_unit() const
-    {
-      for (size_t i = 0, S = numerator_units_.size(); i < S; ++i) {
-        string u(numerator_units_[i]);
-        if (string_to_unit(u) != INCOMMENSURABLE) return u;
-      }
-      for (size_t i = 0, S = denominator_units_.size(); i < S; ++i) {
-        string u(denominator_units_[i]);
-        if (string_to_unit(u) != INCOMMENSURABLE) return u;
-      }
-      return string();
-    }
+    string find_convertible_unit() const;
 
-    virtual bool operator==(Expression& rhs) const
-    {
-      try
-      {
-        Number& e(dynamic_cast<Number&>(rhs));
-        if (!e) return false;
-        e.normalize(find_convertible_unit());
-        return unit() == e.unit() && value() == e.value();
-      }
-      catch (std::bad_cast&)
-      {
-        return false;
-      }
-      catch (...) { throw; }
-    }
+    virtual bool operator== (Expression& rhs) const;
+    virtual bool operator== (Expression* rhs) const;
 
     virtual size_t hash()
     {