sassc 1.8.1 → 1.8.2

data/ext/libsass/src/ast.cpp

@@ -894,6 +894,11 @@ namespace Sass {
             tss->name(tss->name() + (*h)[0]->name());
             (*rh)[rh->length()-1] = tss;
             for (i = 1; i < L; ++i) *rh << (*h)[i];
+          } else if (Selector_Placeholder* ps = dynamic_cast<Selector_Placeholder*>(rh->last())) {
+            Selector_Placeholder* pss = new Selector_Placeholder(*ps);
+            pss->name(pss->name() + (*h)[0]->name());
+            (*rh)[rh->length()-1] = pss;
+            for (i = 1; i < L; ++i) *rh << (*h)[i];
           } else {
             *last()->head_ += h;
           }
@@ -978,6 +983,11 @@ namespace Sass {
               Complex_Selector* parent = (*parents)[i];
               Complex_Selector* s = parent->cloneFully(ctx);
               Complex_Selector* ss = this->clone(ctx);
+              // this is only if valid if the parent has no trailing op
+              // otherwise we cannot append more simple selectors to head
+              if (parent->last()->combinator() != ANCESTOR_OF) {
+                throw Exception::InvalidParent(parent, ss);
+              }
               ss->tail(tail ? tail->clone(ctx) : 0);
               Compound_Selector* h = head_->clone(ctx);
               if (h->length()) h->erase(h->begin());
@@ -1004,7 +1014,7 @@ namespace Sass {
               *retval << cpy->skip_empty_reference();
             }
           }
-          // have no parent and not tails
+          // have no parent nor tails
           else {
             Complex_Selector* cpy = this->clone(ctx);
             cpy->head(SASS_MEMORY_NEW(ctx.mem, Compound_Selector, head->pstate()));
@@ -1859,17 +1869,17 @@ namespace Sass {
     // resolved color
     std::string res_name = name;
 
-    double r = round(cap_channel<0xff>(r_));
-    double g = round(cap_channel<0xff>(g_));
-    double b = round(cap_channel<0xff>(b_));
+    double r = Sass::round(cap_channel<0xff>(r_));
+    double g = Sass::round(cap_channel<0xff>(g_));
+    double b = Sass::round(cap_channel<0xff>(b_));
     double a = cap_channel<1>   (a_);
 
     // get color from given name (if one was given at all)
     if (name != "" && name_to_color(name)) {
       const Color* n = name_to_color(name);
-      r = round(cap_channel<0xff>(n->r()));
-      g = round(cap_channel<0xff>(n->g()));
-      b = round(cap_channel<0xff>(n->b()));
+      r = Sass::round(cap_channel<0xff>(n->r()));
+      g = Sass::round(cap_channel<0xff>(n->g()));
+      b = Sass::round(cap_channel<0xff>(n->b()));
       a = cap_channel<1>   (n->a());
     }
     // otherwise get the possible resolved color name
@@ -2020,6 +2030,91 @@ namespace Sass {
     return message();
   }
 
+  std::string Selector_List::to_string(bool compressed, int precision) const
+  {
+    std::string str("");
+    auto end = this->end();
+    auto start = this->begin();
+    while (start < end && *start) {
+      Complex_Selector* sel = *start;
+      if (!str.empty()) str += ", ";
+      str += sel->to_string(compressed, precision);
+      ++ start;
+    }
+    return str;
+  }
+
+  std::string Compound_Selector::to_string(bool compressed, int precision) const
+  {
+    std::string str("");
+    auto end = this->end();
+    auto start = this->begin();
+    while (start < end && *start) {
+      Simple_Selector* sel = *start;
+      str += sel->to_string(compressed, precision);
+      ++ start;
+    }
+    return str;
+  }
+
+  std::string Complex_Selector::to_string(bool compressed, int precision) const
+  {
+    // first render head and tail if they are available
+    std::string str_head(head() ? head()->to_string(compressed, precision) : "");
+    std::string str_tail(tail() ? tail()->to_string(compressed, precision) : "");
+    std::string str_ref(reference() ? reference()->to_string(compressed, precision) : "");
+    // combinator in between
+    std::string str_op("");
+    // use a switch statement
+    switch (combinator()) {
+      case ANCESTOR_OF: str_op = " "; break;
+      case PARENT_OF:   str_op = ">"; break;
+      case PRECEDES:    str_op = "~"; break;
+      case ADJACENT_TO: str_op = "+"; break;
+      case REFERENCE:   str_op = "/" + str_ref + "/"; break;
+    }
+    // prettify for non ancestors
+    if (combinator() != ANCESTOR_OF) {
+      // no spaces needed for compressed
+      if (compressed == false) {
+        // make sure we add some spaces where needed
+        if (str_tail != "") str_op += " ";
+        if (str_head != "") str_head += " ";
+      }
+    }
+    // is ancestor with no tail
+    else if (str_tail == "") {
+      str_op = ""; // superflous
+    }
+    // now build the final result
+    return str_head + str_op + str_tail;
+  }
+
+  std::string Selector_Schema::to_string(bool compressed, int precision) const
+  {
+    return contents()->to_string(compressed, precision);
+  }
+
+  std::string Parent_Selector::to_string(bool compressed, int precision) const
+  {
+    return "&";
+  }
+
+  std::string Attribute_Selector::to_string(bool compressed, int precision) const
+  {
+    std::string val(value() ? value()->to_string(compressed, precision) : "");
+    return "[" + this->ns_name() + this->matcher() + val + "]";
+  }
+
+  std::string Wrapped_Selector::to_string(bool compressed, int precision) const
+  {
+    // first render the
+    std::string main(this->Simple_Selector::to_string(compressed, precision));
+    std::string wrapped(selector() ? selector()->to_string(compressed, precision) : "");
+    // now build the final result
+    return main + "(" + wrapped + ")";
+  }
+
   //////////////////////////////////////////////////////////////////////////////////////////
   // Additional method on Lists to retrieve values directly or from an encompassed Argument.
   //////////////////////////////////////////////////////////////////////////////////////////

data/ext/libsass/src/ast.hpp

@@ -10,6 +10,7 @@
 #include <typeinfo>
 #include <algorithm>
 #include <unordered_map>
+#include "sass/base.h"
 
 #ifdef __clang__
 
@@ -537,26 +538,32 @@ namespace Sass {
   // necessary to store a list of each in an Import node.
   ////////////////////////////////////////////////////////////////////////////
   class Import : public Statement {
-    std::vector<std::string>         files_;
-    std::vector<Expression*>    urls_;
-    ADD_PROPERTY(List*, media_queries);
+    std::vector<Expression*> urls_;
+    std::vector<Include>     incs_;
+    ADD_PROPERTY(List*,      media_queries);
   public:
     Import(ParserState pstate)
     : Statement(pstate),
-      files_(std::vector<std::string>()),
       urls_(std::vector<Expression*>()),
+      incs_(std::vector<Include>()),
       media_queries_(0)
     { statement_type(IMPORT); }
-    std::vector<std::string>&      files()    { return files_; }
-    std::vector<Expression*>& urls()     { return urls_; }
+    std::vector<Expression*>& urls() { return urls_; }
+    std::vector<Include>& incs() { return incs_; }
     ATTACH_OPERATIONS()
   };
 
+  // not yet resolved single import
+  // so far we only know requested name
   class Import_Stub : public Statement {
-    ADD_PROPERTY(std::string, file_name)
+    Include resource_;
   public:
-    Import_Stub(ParserState pstate, std::string f)
-    : Statement(pstate), file_name_(f)
+    std::string abs_path() { return resource_.abs_path; };
+    std::string imp_path() { return resource_.imp_path; };
+    Include resource() { return resource_; };
+
+    Import_Stub(ParserState pstate, Include res)
+    : Statement(pstate), resource_(res)
     { statement_type(IMPORT_STUB); }
     ATTACH_OPERATIONS()
   };
@@ -622,6 +629,10 @@ namespace Sass {
     If(ParserState pstate, Expression* pred, Block* con, Block* alt = 0)
     : Has_Block(pstate, con), predicate_(pred), alternative_(alt)
     { statement_type(IF); }
+    virtual bool has_content()
+    {
+      return Has_Block::has_content() || (alternative_ && alternative_->has_content());
+    }
     ATTACH_OPERATIONS()
   };
 
@@ -880,9 +891,9 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////////
   class Binary_Expression : public Expression {
   private:
-    ADD_PROPERTY(enum Sass_OP, type)
-    ADD_PROPERTY(Expression*, left)
-    ADD_PROPERTY(Expression*, right)
+    ADD_HASHED(enum Sass_OP, type)
+    ADD_HASHED(Expression*, left)
+    ADD_HASHED(Expression*, right)
     size_t hash_;
   public:
     Binary_Expression(ParserState pstate,
@@ -949,8 +960,8 @@ namespace Sass {
   public:
     enum Type { PLUS, MINUS, NOT };
   private:
-    ADD_PROPERTY(Type, type)
-    ADD_PROPERTY(Expression*, operand)
+    ADD_HASHED(Type, type)
+    ADD_HASHED(Expression*, operand)
     size_t hash_;
   public:
     Unary_Expression(ParserState pstate, Type t, Expression* o)
@@ -994,8 +1005,8 @@ namespace Sass {
   // Individual argument objects for mixin and function calls.
   ////////////////////////////////////////////////////////////
   class Argument : public Expression {
-    ADD_PROPERTY(Expression*, value)
-    ADD_PROPERTY(std::string, name)
+    ADD_HASHED(Expression*, value)
+    ADD_HASHED(std::string, name)
     ADD_PROPERTY(bool, is_rest_argument)
     ADD_PROPERTY(bool, is_keyword_argument)
     size_t hash_;
@@ -1061,8 +1072,8 @@ namespace Sass {
   // Function calls.
   //////////////////
   class Function_Call : public Expression {
-    ADD_PROPERTY(std::string, name)
-    ADD_PROPERTY(Arguments*, arguments)
+    ADD_HASHED(std::string, name)
+    ADD_HASHED(Arguments*, arguments)
     ADD_PROPERTY(void*, cookie)
     size_t hash_;
   public:
@@ -1157,8 +1168,8 @@ namespace Sass {
   public:
     enum Type { NUMBER, PERCENTAGE, DIMENSION, HEX };
   private:
-    ADD_PROPERTY(Type, type)
-    ADD_PROPERTY(std::string, value)
+    ADD_HASHED(Type, type)
+    ADD_HASHED(std::string, value)
     size_t hash_;
   public:
     Textual(ParserState pstate, Type t, std::string val)
@@ -1196,7 +1207,7 @@ namespace Sass {
   // Numbers, percentages, dimensions, and colors.
   ////////////////////////////////////////////////
   class Number : public Value {
-    ADD_PROPERTY(double, value)
+    ADD_HASHED(double, value)
     ADD_PROPERTY(bool, zero)
     std::vector<std::string> numerator_units_;
     std::vector<std::string> denominator_units_;
@@ -1222,6 +1233,10 @@ namespace Sass {
     {
       if (hash_ == 0) {
         hash_ = std::hash<double>()(value_);
+        for (const auto numerator : numerator_units())
+          hash_combine(hash_, std::hash<std::string>()(numerator));
+        for (const auto denominator : denominator_units())
+          hash_combine(hash_, std::hash<std::string>()(denominator));
       }
       return hash_;
     }
@@ -1237,10 +1252,10 @@ namespace Sass {
   // Colors.
   //////////
   class Color : public Value {
-    ADD_PROPERTY(double, r)
-    ADD_PROPERTY(double, g)
-    ADD_PROPERTY(double, b)
-    ADD_PROPERTY(double, a)
+    ADD_HASHED(double, r)
+    ADD_HASHED(double, g)
+    ADD_HASHED(double, b)
+    ADD_HASHED(double, a)
     ADD_PROPERTY(bool, sixtuplet)
     ADD_PROPERTY(std::string, disp)
     size_t hash_;
@@ -1301,7 +1316,7 @@ namespace Sass {
   // Booleans.
   ////////////
   class Boolean : public Value {
-    ADD_PROPERTY(bool, value)
+    ADD_HASHED(bool, value)
     size_t hash_;
   public:
     Boolean(ParserState pstate, bool val)
@@ -1380,7 +1395,7 @@ namespace Sass {
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark)
     ADD_PROPERTY(bool, can_compress_whitespace)
-    ADD_PROPERTY(std::string, value)
+    ADD_HASHED(std::string, value)
   protected:
     size_t hash_;
   public:
@@ -1756,6 +1771,7 @@ namespace Sass {
     virtual unsigned long specificity() {
       return Constants::Specificity_Universal;
     }
+    virtual std::string to_string(bool compressed = false, int precision = 5) const = 0;
   };
   inline Selector::~Selector() { }
 
@@ -1770,6 +1786,7 @@ namespace Sass {
     Selector_Schema(ParserState pstate, String* c)
     : Selector(pstate), contents_(c), at_root_(false)
     { }
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1838,6 +1855,8 @@ namespace Sass {
     inline bool operator!=(const Simple_Selector& rhs) const { return !(*this == rhs); }
 
     bool operator<(const Simple_Selector& rhs) const;
+    // default implementation should work for most of the simple selectors (otherwise overload)
+    virtual std::string to_string(bool compressed = false, int precision = 5) const { return this->ns_name(); };
     ATTACH_OPERATIONS();
   };
   inline Simple_Selector::~Simple_Selector() { }
@@ -1861,6 +1880,7 @@ namespace Sass {
     }
     std::string type() { return "selector"; }
     static std::string type_name() { return "selector"; }
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1873,6 +1893,7 @@ namespace Sass {
     : Simple_Selector(pstate, n)
     { has_placeholder(true); }
     // virtual Selector_Placeholder* find_placeholder();
+    virtual ~Selector_Placeholder() {};
     ATTACH_OPERATIONS()
   };
 
@@ -1931,6 +1952,7 @@ namespace Sass {
     bool operator==(const Attribute_Selector& rhs) const;
     bool operator<(const Simple_Selector& rhs) const;
     bool operator<(const Attribute_Selector& rhs) const;
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2005,6 +2027,7 @@ namespace Sass {
     }
     bool operator==(const Simple_Selector& rhs) const;
     bool operator==(const Wrapped_Selector& rhs) const;
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2091,6 +2114,7 @@ namespace Sass {
     Compound_Selector* clone(Context&) const; // does not clone the Simple_Selector*s
 
     Compound_Selector* minus(Compound_Selector* rhs, Context& ctx);
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2239,6 +2263,7 @@ namespace Sass {
     Complex_Selector* clone(Context&) const;      // does not clone Compound_Selector*s
     Complex_Selector* cloneFully(Context&) const; // clones Compound_Selector*s
     // std::vector<Compound_Selector*> to_vector();
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2284,6 +2309,7 @@ namespace Sass {
     virtual bool operator==(const Selector_List& rhs) const;
     // Selector Lists can be compared to comma lists
     virtual bool operator==(const Expression& rhs) const;
+    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 

data/ext/libsass/src/ast_def_macros.hpp

@@ -44,4 +44,12 @@ public:\
   type name(type name##__) { return name##_ = name##__; }\
 private:
 
+#define ADD_HASHED(type, name)\
+protected:\
+  type name##_;\
+public:\
+  type name() const        { return name##_; }\
+  type name(type name##__) { hash_ = 0; return name##_ = name##__; }\
+private:
+
 #endif

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -6,8 +6,6 @@
 /////////////////////////////////////////////
 namespace Sass {
 
-  enum Output_Style { NESTED, EXPANDED, COMPACT, COMPRESSED, FORMATTED };
-
   class AST_Node;
   // statements
   class Statement;
@@ -85,6 +83,9 @@ namespace Sass {
   class Complex_Selector;
   class Selector_List;
 
+  // common classes
+  class Context;
+
 }
 
 #endif

data/ext/libsass/src/backtrace.hpp

@@ -33,7 +33,7 @@ namespace Sass {
       while (this_point->parent) {
 
         // make path relative to the current directory
-        std::string rel_path(Sass::File::resolve_relative_path(this_point->pstate.path, cwd, cwd));
+        std::string rel_path(Sass::File::abs2rel(this_point->pstate.path, cwd, cwd));
 
         if (warning) {
           ss << std::endl

data/ext/libsass/src/bind.cpp

@@ -9,9 +9,10 @@
 
 namespace Sass {
 
-  void bind(std::string callee, Parameters* ps, Arguments* as, Context& ctx, Env* env, Eval* eval)
+  void bind(std::string type, std::string name, Parameters* ps, Arguments* as, Context* ctx, Env* env, Eval* eval)
   {
-    Listize listize(ctx);
+    std::string callee(type + " " + name);
+    Listize listize(*ctx);
     std::map<std::string, Parameter*> param_map;
 
     for (size_t i = 0, L = as->length(); i < L; ++i) {
@@ -49,9 +50,9 @@ namespace Sass {
           }
         }
         std::stringstream msg;
-        msg << callee << " only takes " << LP << " arguments; "
-            << "given " << LA;
-        error(msg.str(), as->pstate());
+        msg << "wrong number of arguments (" << LA << " for " << LP << ")";
+        msg << " for `" << name << "'";
+        return error(msg.str(), as->pstate());
       }
       Parameter* p = (*ps)[ip];
 
@@ -72,14 +73,14 @@ namespace Sass {
             // otherwise we will not be able to fetch it again
             else {
               // create a new list object for wrapped items
-              List* arglist = SASS_MEMORY_NEW(ctx.mem, List,
+              List* arglist = SASS_MEMORY_NEW(ctx->mem, List,
                                               p->pstate(),
                                               0,
                                               rest->separator(),
                                               true);
               // wrap each item from list as an argument
               for (Expression* item : rest->elements()) {
-                (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
                                               item->pstate(),
                                               item,
                                               "",
@@ -97,12 +98,12 @@ namespace Sass {
         } else if (a->is_keyword_argument()) {
 
           // expand keyword arguments into their parameters
-          List* arglist = SASS_MEMORY_NEW(ctx.mem, List, p->pstate(), 0, SASS_COMMA, true);
+          List* arglist = SASS_MEMORY_NEW(ctx->mem, List, p->pstate(), 0, SASS_COMMA, true);
           env->local_frame()[p->name()] = arglist;
           Map* argmap = static_cast<Map*>(a->value());
           for (auto key : argmap->keys()) {
             std::string name = unquote(static_cast<String_Constant*>(key)->value());
-            (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+            (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
                                           key->pstate(),
                                           argmap->at(key),
                                           "$" + name,
@@ -113,7 +114,7 @@ namespace Sass {
         } else {
 
           // create a new list object for wrapped items
-          List* arglist = SASS_MEMORY_NEW(ctx.mem, List,
+          List* arglist = SASS_MEMORY_NEW(ctx->mem, List,
                                           p->pstate(),
                                           0,
                                           SASS_COMMA,
@@ -131,11 +132,11 @@ namespace Sass {
               for (size_t i = 0, L = ls->size(); i < L; ++i) {
                 // already have a wrapped argument
                 if (Argument* arg = dynamic_cast<Argument*>((*ls)[i])) {
-                  (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument, *arg);
+                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
                 }
                 // wrap all other value types into Argument
                 else {
-                  (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+                  (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
                                                 (*ls)[i]->pstate(),
                                                 (*ls)[i],
                                                 "",
@@ -146,11 +147,11 @@ namespace Sass {
             }
             // already have a wrapped argument
             else if (Argument* arg = dynamic_cast<Argument*>(a->value())) {
-              (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument, *arg);
+              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument, *arg);
             }
             // wrap all other value types into Argument
             else {
-              (*arglist) << SASS_MEMORY_NEW(ctx.mem, Argument,
+              (*arglist) << SASS_MEMORY_NEW(ctx->mem, Argument,
                                             a->pstate(),
                                             a->value(),
                                             a->name(),
@@ -183,11 +184,21 @@ namespace Sass {
         // empty rest arg - treat all args as default values
         if (!arglist->length()) {
           break;
+        } else {
+          if (arglist->length() + ia > LP && !ps->has_rest_parameter()) {
+            int arg_count = (arglist->length() + LA - 1);
+            std::stringstream msg;
+            msg << callee << " takes " << LP;
+            msg << (LP == 1 ? " argument" : " arguments");
+            msg << " but " << arg_count;
+            msg << (arg_count == 1 ? " was passed" : " were passed.");
+            deprecated_bind(msg.str(), as->pstate());
+          }
         }
         // otherwise move one of the rest args into the param, converting to argument if necessary
         if (!(a = dynamic_cast<Argument*>((*arglist)[0]))) {
           Expression* a_to_convert = (*arglist)[0];
-          a = SASS_MEMORY_NEW(ctx.mem, Argument,
+          a = SASS_MEMORY_NEW(ctx->mem, Argument,
                               a_to_convert->pstate(),
                               a_to_convert,
                               "",
@@ -256,14 +267,14 @@ namespace Sass {
     // That's only okay if they have default values, or were already bound by
     // named arguments, or if it's a single rest-param.
     for (size_t i = ip; i < LP; ++i) {
-      To_String to_string(&ctx);
+      To_String to_string(ctx);
       Parameter* leftover = (*ps)[i];
       // cerr << "env for default params:" << endl;
       // env->print();
       // cerr << "********" << endl;
       if (!env->has_local(leftover->name())) {
         if (leftover->is_rest_parameter()) {
-          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(ctx.mem, List,
+          env->local_frame()[leftover->name()] = SASS_MEMORY_NEW(ctx->mem, List,
                                                                    leftover->pstate(),
                                                                    0,
                                                                    SASS_COMMA,