sassc 1.11.4 → 1.12.0

data/ext/libsass/src/subset_map.cpp

@@ -4,22 +4,20 @@
 
 namespace Sass {
 
-  void Subset_Map::put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value)
+  void Subset_Map::put(const Compound_Selector_Obj& sel, const SubSetMapPair& value)
   {
     if (sel->empty()) throw std::runtime_error("internal error: subset map keys may not be empty");
     size_t index = values_.size();
     values_.push_back(value);
     for (size_t i = 0, S = sel->length(); i < S; ++i)
     {
-      hash_[(*sel)[i]].push_back(std::make_pair(&sel, index));
+      hash_[(*sel)[i]].push_back(std::make_pair(sel, index));
     }
   }
 
-  std::vector<Subset_Map_Val> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
+  std::vector<SubSetMapPair> Subset_Map::get_kv(const Compound_Selector_Obj& sel)
   {
-    // std::vector<Subset_Map_Key> s = sel->to_str_vec();
-    // std::set<std::string> dict(s.begin(), s.end());
-    std::unordered_set<Simple_Selector_Obj, HashSimpleSelector, CompareSimpleSelector> dict(sel->begin(), sel->end());
+    SimpleSelectorDict dict(sel->begin(), sel->end()); // XXX Set
     std::vector<size_t> indices;
     for (size_t i = 0, S = sel->length(); i < S; ++i) {
       if (!hash_.count((*sel)[i])) {
@@ -42,14 +40,14 @@ namespace Sass {
     std::vector<size_t>::iterator indices_end = unique(indices.begin(), indices.end());
     indices.resize(distance(indices.begin(), indices_end));
 
-    std::vector<Subset_Map_Val> results;
+    std::vector<SubSetMapPair> results;
     for (size_t i = 0, S = indices.size(); i < S; ++i) {
       results.push_back(values_[indices[i]]);
     }
     return results;
   }
 
-  std::vector<Subset_Map_Val> Subset_Map::get_v(const Compound_Selector_Obj& sel)
+  std::vector<SubSetMapPair> Subset_Map::get_v(const Compound_Selector_Obj& sel)
   {
     return get_kv(sel);
   }

data/ext/libsass/src/subset_map.hpp

@@ -60,15 +60,15 @@ namespace Sass {
 
   class Subset_Map {
   private:
-    std::vector<Subset_Map_Val> values_;
-    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> > > hash_;
+    std::vector<SubSetMapPair> values_;
+    std::map<Simple_Selector_Obj, std::vector<std::pair<Compound_Selector_Obj, size_t> >, OrderNodes > hash_;
   public:
-    void put(const Compound_Selector_Obj& sel, const Subset_Map_Val& value);
-    std::vector<Subset_Map_Val> get_kv(const Compound_Selector_Obj& s);
-    std::vector<Subset_Map_Val> get_v(const Compound_Selector_Obj& s);
+    void put(const Compound_Selector_Obj& sel, const SubSetMapPair& value);
+    std::vector<SubSetMapPair> get_kv(const Compound_Selector_Obj& s);
+    std::vector<SubSetMapPair> get_v(const Compound_Selector_Obj& s);
     bool empty() { return values_.empty(); }
     void clear() { values_.clear(); hash_.clear(); }
-    const std::vector<Subset_Map_Val> values(void) { return values_; }
+    const std::vector<SubSetMapPair> values(void) { return values_; }
   };
 
 }

data/ext/libsass/src/to_c.cpp

@@ -36,7 +36,7 @@ namespace Sass {
 
   union Sass_Value* To_C::operator()(List_Ptr l)
   {
-    union Sass_Value* v = sass_make_list(l->length(), l->separator());
+    union Sass_Value* v = sass_make_list(l->length(), l->separator(), l->is_bracketed());
     for (size_t i = 0, L = l->length(); i < L; ++i) {
       sass_list_set_value(v, i, (*l)[i]->perform(this));
     }
@@ -57,7 +57,7 @@ namespace Sass {
 
   union Sass_Value* To_C::operator()(Arguments_Ptr a)
   {
-    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA);
+    union Sass_Value* v = sass_make_list(a->length(), SASS_COMMA, false);
     for (size_t i = 0, L = a->length(); i < L; ++i) {
       sass_list_set_value(v, i, (*a)[i]->perform(this));
     }

data/ext/libsass/src/to_value.cpp

@@ -9,8 +9,6 @@ namespace Sass {
     // throw a runtime error if this happens
     // we want a well defined set of possible nodes
     throw std::runtime_error("invalid node for to_value");
-    // mute warning
-    return 0;
   }
 
   // Custom_Error is a valid value
@@ -62,7 +60,8 @@ namespace Sass {
                                l->pstate(),
                                l->length(),
                                l->separator(),
-                               l->is_arglist());
+                               l->is_arglist(),
+                               l->is_bracketed());
     for (size_t i = 0, L = l->length(); i < L; ++i) {
       ll->append((*l)[i]->perform(this));
     }
@@ -81,6 +80,12 @@ namespace Sass {
     return n;
   }
 
+  // Function is a valid value
+  Value_Ptr To_Value::operator()(Function_Ptr n)
+  {
+    return n;
+  }
+
   // Argument returns its value
   Value_Ptr To_Value::operator()(Argument_Ptr arg)
   {

data/ext/libsass/src/to_value.hpp

@@ -34,6 +34,7 @@ namespace Sass {
     Value_Ptr operator()(List_Ptr);
     Value_Ptr operator()(Map_Ptr);
     Value_Ptr operator()(Null_Ptr);
+    Value_Ptr operator()(Function_Ptr);
 
     // convert to string via `To_String`
     Value_Ptr operator()(Selector_List_Ptr);

data/ext/libsass/src/units.cpp

@@ -1,6 +1,7 @@
 #include "sass.hpp"
 #include <stdexcept>
 #include "units.hpp"
+#include "error_handling.hpp"
 
 namespace Sass {
 
@@ -53,12 +54,12 @@ namespace Sass {
   {
     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;
+      case UnitClass::LENGTH:      return UnitClass::LENGTH;
+      case UnitClass::ANGLE:       return UnitClass::ANGLE;
+      case UnitClass::TIME:        return UnitClass::TIME;
+      case UnitClass::FREQUENCY:   return UnitClass::FREQUENCY;
+      case UnitClass::RESOLUTION:  return UnitClass::RESOLUTION;
+      default:                     return UnitClass::INCOMMENSURABLE;
     }
   };
 
@@ -66,12 +67,25 @@ namespace Sass {
   {
     switch (unit & 0xFF00)
     {
-      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;
+      case UnitClass::LENGTH:      return "LENGTH";
+      case UnitClass::ANGLE:       return "ANGLE";
+      case UnitClass::TIME:        return "TIME";
+      case UnitClass::FREQUENCY:   return "FREQUENCY";
+      case UnitClass::RESOLUTION:  return "RESOLUTION";
+      default:                     return "INCOMMENSURABLE";
+    }
+  };
+
+  UnitType get_main_unit(const UnitClass unit)
+  {
+    switch (unit)
+    {
+      case UnitClass::LENGTH:      return UnitType::PX;
+      case UnitClass::ANGLE:       return UnitType::DEG;
+      case UnitClass::TIME:        return UnitType::SEC;
+      case UnitClass::FREQUENCY:   return UnitType::HERTZ;
+      case UnitClass::RESOLUTION:  return UnitType::DPI;
+      default:                     return UnitType::UNKNOWN;
     }
   };
 
@@ -107,29 +121,29 @@ namespace Sass {
   {
     switch (unit) {
       // size units
-      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;
+      case UnitType::PX:      return "px";
+      case UnitType::PT:      return "pt";
+      case UnitType::PC:      return "pc";
+      case UnitType::MM:      return "mm";
+      case UnitType::CM:      return "cm";
+      case UnitType::IN:      return "in";
       // angle units
-      case UnitType::DEG:     return "deg"; break;
-      case UnitType::GRAD:    return "grad"; break;
-      case UnitType::RAD:     return "rad"; break;
-      case UnitType::TURN:    return "turn"; break;
+      case UnitType::DEG:     return "deg";
+      case UnitType::GRAD:    return "grad";
+      case UnitType::RAD:     return "rad";
+      case UnitType::TURN:    return "turn";
       // time units
-      case UnitType::SEC:     return "s"; break;
-      case UnitType::MSEC:    return "ms"; break;
+      case UnitType::SEC:     return "s";
+      case UnitType::MSEC:    return "ms";
       // frequency units
-      case UnitType::HERTZ:   return "Hz"; break;
-      case UnitType::KHERTZ:  return "kHz"; break;
+      case UnitType::HERTZ:   return "Hz";
+      case UnitType::KHERTZ:  return "kHz";
       // resolutions units
-      case UnitType::DPI:     return "dpi"; break;
-      case UnitType::DPCM:    return "dpcm"; break;
-      case UnitType::DPPX:    return "dppx"; break;
+      case UnitType::DPI:     return "dpi";
+      case UnitType::DPCM:    return "dpcm";
+      case UnitType::DPPX:    return "dppx";
       // for unknown units
-      default:                return ""; break;
+      default:                return "";
     }
   }
 
@@ -161,7 +175,7 @@ namespace Sass {
   }
 
   // throws incompatibleUnits exceptions
-  double conversion_factor(const std::string& s1, const std::string& s2, bool strict)
+  double conversion_factor(const std::string& s1, const std::string& s2)
   {
     // assert for same units
     if (s1 == s2) return 1;
@@ -171,27 +185,317 @@ namespace Sass {
     // query unit group types
     UnitClass t1 = get_unit_type(u1);
     UnitClass t2 = get_unit_type(u2);
+    // return the conversion factor
+    return conversion_factor(u1, u2, t1, t2);
+  }
+
+  // throws incompatibleUnits exceptions
+  double conversion_factor(UnitType u1, UnitType u2, UnitClass t1, UnitClass t2)
+  {
+    // can't convert between groups
+    if (t1 != t2) return 0;
     // get absolute offset
     // used for array acces
     size_t i1 = u1 - t1;
     size_t i2 = u2 - t2;
-    // error if units are not of the same group
-    // don't error for multiplication and division
-    if (strict && t1 != t2) throw incompatibleUnits(u1, u2);
-    // only process known units
-    if (u1 != UNKNOWN && u2 != UNKNOWN) {
-      switch (t1) {
-        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 UnitClass::INCOMMENSURABLE:   return 0; break;
-      }
+    // process known units
+    switch (t1) {
+      case LENGTH:
+        return size_conversion_factors[i1][i2];
+      case ANGLE:
+        return angle_conversion_factors[i1][i2];
+      case TIME:
+        return time_conversion_factors[i1][i2];
+      case FREQUENCY:
+        return frequency_conversion_factors[i1][i2];
+      case RESOLUTION:
+        return resolution_conversion_factors[i1][i2];
+      case INCOMMENSURABLE:
+        return 0;
     }
     // fallback
     return 0;
   }
 
+  double convert_units(const std::string& lhs, const std::string& rhs, int& lhsexp, int& rhsexp)
+  {
+    double f = 0;
+    // do not convert same ones
+    if (lhs == rhs) return 0;
+    // skip already canceled out unit
+    if (lhsexp == 0) return 0;
+    if (rhsexp == 0) return 0;
+    // check if it can be converted
+    UnitType ulhs = string_to_unit(lhs);
+    UnitType urhs = string_to_unit(rhs);
+    // skip units we cannot convert
+    if (ulhs == UNKNOWN) return 0;
+    if (urhs == UNKNOWN) return 0;
+    // query unit group types
+    UnitClass clhs = get_unit_type(ulhs);
+    UnitClass crhs = get_unit_type(urhs);
+    // skip units we cannot convert
+    if (clhs != crhs) return 0;
+    // if right denominator is bigger than lhs, we want to keep it in rhs unit
+    if (rhsexp < 0 && lhsexp > 0 && - rhsexp > lhsexp) {
+      // get the conversion factor for units
+      f = conversion_factor(urhs, ulhs, clhs, crhs);
+      // left hand side has been consumned
+      f = std::pow(f, lhsexp);
+      rhsexp += lhsexp;
+      lhsexp = 0;
+    }
+    else {
+      // get the conversion factor for units
+      f = conversion_factor(ulhs, urhs, clhs, crhs);
+      // right hand side has been consumned
+      f = std::pow(f, rhsexp);
+      lhsexp += rhsexp;
+      rhsexp = 0;
+    }
+    return f;
+  }
+
+  bool Units::operator< (const Units& rhs) const
+  {
+    return (numerators < rhs.numerators) &&
+           (denominators < rhs.denominators);
+  }
+  bool Units::operator== (const Units& rhs) const
+  {
+    return (numerators == rhs.numerators) &&
+           (denominators == rhs.denominators);
+  }
+
+  double Units::normalize()
+  {
+
+    size_t iL = numerators.size();
+    size_t nL = denominators.size();
+
+    // the final conversion factor
+    double factor = 1;
+
+    for (size_t i = 0; i < iL; i++) {
+      std::string &lhs = numerators[i];
+      UnitType ulhs = string_to_unit(lhs);
+      if (ulhs == UNKNOWN) continue;
+      UnitClass clhs = get_unit_type(ulhs);
+      UnitType umain = get_main_unit(clhs);
+      if (ulhs == umain) continue;
+      double f(conversion_factor(umain, ulhs, clhs, clhs));
+      if (f == 0) throw std::runtime_error("INVALID");
+      numerators[i] = unit_to_string(umain);
+      factor /= f;
+    }
+
+    for (size_t n = 0; n < nL; n++) {
+      std::string &rhs = denominators[n];
+      UnitType urhs = string_to_unit(rhs);
+      if (urhs == UNKNOWN) continue;
+      UnitClass crhs = get_unit_type(urhs);
+      UnitType umain = get_main_unit(crhs);
+      if (urhs == umain) continue;
+      double f(conversion_factor(umain, urhs, crhs, crhs));
+      if (f == 0) throw std::runtime_error("INVALID");
+      denominators[n] = unit_to_string(umain);
+      factor /= f;
+    }
+
+    std::sort (numerators.begin(), numerators.end());
+    std::sort (denominators.begin(), denominators.end());
+
+    // return for conversion
+    return factor;
+  }
+
+  double Units::reduce()
+  {
+
+    size_t iL = numerators.size();
+    size_t nL = denominators.size();
+
+    // have less than two units?
+    if (iL + nL < 2) return 1;
+
+    // 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
+    std::map<std::string, int> exponents;
+
+    // initialize by summing up occurences 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;
+
+    // the final conversion factor
+    double factor = 1;
+
+    // convert between compatible units
+    for (size_t i = 0; i < iL; i++) {
+      for (size_t n = 0; n < nL; n++) {
+        std::string &lhs = numerators[i], &rhs = denominators[n];
+        int &lhsexp = exponents[lhs], &rhsexp = exponents[rhs];
+        double f(convert_units(lhs, rhs, lhsexp, rhsexp));
+        if (f == 0) continue;
+        factor /= f;
+      }
+    }
+
+    // now we can build up the new unit arrays
+    numerators.clear();
+    denominators.clear();
+
+    // recreate sorted units vectors
+    for (auto exp : exponents) {
+      int &exponent = exp.second;
+      while (exponent > 0 && exponent --)
+        numerators.push_back(exp.first);
+      while (exponent < 0 && exponent ++)
+        denominators.push_back(exp.first);
+    }
+
+    // return for conversion
+    return factor;
+
+  }
+
+  std::string Units::unit() const
+  {
+    std::string u;
+    size_t iL = numerators.size();
+    size_t nL = denominators.size();
+    for (size_t i = 0; i < iL; i += 1) {
+      if (i) u += '*';
+      u += numerators[i];
+    }
+    if (nL != 0) u += '/';
+    for (size_t n = 0; n < nL; n += 1) {
+      if (n) u += '*';
+      u += denominators[n];
+    }
+    return u;
+  }
+
+  bool Units::is_unitless() const
+  {
+    return numerators.empty() &&
+           denominators.empty();
+  }
+
+  bool Units::is_valid_css_unit() const
+  {
+    return numerators.size() <= 1 &&
+           denominators.size() == 0;
+  }
+
+  // this does not cover all cases (multiple prefered units)
+  double Units::convert_factor(const Units& r) const
+  {
+
+    std::vector<std::string> miss_nums(0);
+    std::vector<std::string> miss_dens(0);
+    // create copy since we need these for state keeping
+    std::vector<std::string> r_nums(r.numerators);
+    std::vector<std::string> r_dens(r.denominators);
+
+    auto l_num_it = numerators.begin();
+    auto l_num_end = numerators.end();
+
+    bool l_unitless = is_unitless();
+    auto r_unitless = r.is_unitless();
+
+    // overall conversion
+    double factor = 1;
+
+    // process all left numerators
+    while (l_num_it != l_num_end)
+    {
+      // get and increment afterwards
+      const std::string l_num = *(l_num_it ++);
+
+      auto r_num_it = r_nums.begin(), r_num_end = r_nums.end();
+
+      bool found = false;
+      // search for compatible numerator
+      while (r_num_it != r_num_end)
+      {
+        // get and increment afterwards
+        const std::string r_num = *(r_num_it);
+        // get possible conversion factor for units
+        double conversion = conversion_factor(l_num, r_num);
+        // skip incompatible numerator
+        if (conversion == 0) {
+          ++ r_num_it;
+          continue;
+        }
+        // apply to global factor
+        factor *= conversion;
+        // remove item from vector
+        r_nums.erase(r_num_it);
+        // found numerator
+        found = true;
+        break;
+      }
+      // maybe we did not find any
+      // left numerator is leftover
+      if (!found) miss_nums.push_back(l_num);
+    }
+
+    auto l_den_it = denominators.begin();
+    auto l_den_end = denominators.end();
+
+    // process all left denominators
+    while (l_den_it != l_den_end)
+    {
+      // get and increment afterwards
+      const std::string l_den = *(l_den_it ++);
+
+      auto r_den_it = r_dens.begin();
+      auto r_den_end = r_dens.end();
+
+      bool found = false;
+      // search for compatible denominator
+      while (r_den_it != r_den_end)
+      {
+        // get and increment afterwards
+        const std::string r_den = *(r_den_it);
+        // get possible converstion factor for units
+        double conversion = conversion_factor(l_den, r_den);
+        // skip incompatible denominator
+        if (conversion == 0) {
+          ++ r_den_it;
+          continue;
+        }
+        // apply to global factor
+        factor /= conversion;
+        // remove item from vector
+        r_dens.erase(r_den_it);
+        // found denominator
+        found = true;
+        break;
+      }
+      // maybe we did not find any
+      // left denominator is leftover
+      if (!found) miss_dens.push_back(l_den);
+    }
+
+    // check left-overs (ToDo: might cancel out?)
+    if (miss_nums.size() > 0 && !r_unitless) {
+      throw Exception::IncompatibleUnits(r, *this);
+    }
+    else if (miss_dens.size() > 0 && !r_unitless) {
+      throw Exception::IncompatibleUnits(r, *this);
+    }
+    else if (r_nums.size() > 0 && !l_unitless) {
+      throw Exception::IncompatibleUnits(r, *this);
+    }
+    else if (r_dens.size() > 0 && !l_unitless) {
+      throw Exception::IncompatibleUnits(r, *this);
+    }
+
+    return factor;
+  }
+
 }