sassc 1.9.0 → 1.10.0

data/ext/libsass/src/ast.hpp

@@ -277,8 +277,24 @@ namespace Sass {
   // extra <std::vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
   class Hashed {
+  struct HashExpression {
+    size_t operator() (Expression* ex) const {
+      return ex ? ex->hash() : 0;
+    }
+  };
+  struct CompareExpression {
+    bool operator()(const Expression* lhs, const Expression* rhs) const {
+      return lhs && rhs && *lhs == *rhs;
+    }
+  };
+  typedef std::unordered_map<
+    Expression*, // key
+    Expression*, // value
+    HashExpression, // hasher
+    CompareExpression // compare
+  > ExpressionMap;
   private:
-    std::unordered_map<Expression*, Expression*> elements_;
+    ExpressionMap elements_;
     std::vector<Expression*> list_;
   protected:
     size_t hash_;
@@ -287,7 +303,7 @@ namespace Sass {
     void reset_duplicate_key() { duplicate_key_ = 0; }
     virtual void adjust_after_pushing(std::pair<Expression*, Expression*> p) { }
   public:
-    Hashed(size_t s = 0) : elements_(std::unordered_map<Expression*, Expression*>(s)), list_(std::vector<Expression*>())
+    Hashed(size_t s = 0) : elements_(ExpressionMap(s)), list_(std::vector<Expression*>())
     { elements_.reserve(s); list_.reserve(s); reset_duplicate_key(); }
     virtual ~Hashed();
     size_t length() const                  { return list_.size(); }
@@ -296,7 +312,7 @@ namespace Sass {
     Expression* at(Expression* k) const;
     bool has_duplicate_key() const         { return duplicate_key_ != 0; }
     Expression* get_duplicate_key() const  { return duplicate_key_; }
-    const std::unordered_map<Expression*, Expression*> elements() { return elements_; }
+    const ExpressionMap elements() { return elements_; }
     Hashed& operator<<(std::pair<Expression*, Expression*> p)
     {
       reset_hash();
@@ -324,7 +340,7 @@ namespace Sass {
       reset_duplicate_key();
       return *this;
     }
-    const std::unordered_map<Expression*, Expression*>& pairs() const { return elements_; }
+    const ExpressionMap& pairs() const { return elements_; }
     const std::vector<Expression*>& keys() const { return list_; }
 
     std::unordered_map<Expression*, Expression*>::iterator end() { return elements_.end(); }
@@ -508,12 +524,12 @@ namespace Sass {
   // At-rules -- arbitrary directives beginning with "@" that may have an
   // optional statement block.
   ///////////////////////////////////////////////////////////////////////
-  class At_Rule : public Has_Block {
+  class Directive : public Has_Block {
     ADD_PROPERTY(std::string, keyword)
     ADD_PROPERTY(Selector*, selector)
     ADD_PROPERTY(Expression*, value)
   public:
-    At_Rule(ParserState pstate, std::string kwd, Selector* sel = 0, Block* b = 0, Expression* val = 0)
+    Directive(ParserState pstate, std::string kwd, Selector* sel = 0, Block* b = 0, Expression* val = 0)
     : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
     { statement_type(DIRECTIVE); }
     bool bubbles() { return is_keyframes() || is_media(); }
@@ -660,7 +676,7 @@ namespace Sass {
     : Statement(pstate), text_(txt), is_important_(is_important)
     { statement_type(COMMENT); }
     virtual bool is_invisible() const
-    { return is_important() == false; }
+    { return /* is_important() == */ false; }
     ATTACH_OPERATIONS()
   };
 
@@ -840,6 +856,7 @@ namespace Sass {
   // The @content directive for mixin content blocks.
   ///////////////////////////////////////////////////
   class Content : public Statement {
+    ADD_PROPERTY(Media_Block*, media_block)
   public:
     Content(ParserState pstate) : Statement(pstate)
     { statement_type(CONTENT); }
@@ -855,12 +872,15 @@ namespace Sass {
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
+    ADD_PROPERTY(bool, from_selector)
   public:
     List(ParserState pstate,
          size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false)
     : Value(pstate),
       Vectorized<Expression*>(size),
-      separator_(sep), is_arglist_(argl)
+      separator_(sep),
+      is_arglist_(argl),
+      from_selector_(false)
     { concrete_type(LIST); }
     std::string type() { return is_arglist_ ? "arglist" : "list"; }
     static std::string type_name() { return "list"; }
@@ -1011,6 +1031,12 @@ namespace Sass {
       return is_left_interpolant() ||
              is_right_interpolant();
     }
+    virtual bool can_delay() const;
+    void reset_whitespace()
+    {
+      op_.ws_before = false;
+      op_.ws_after = false;
+    }
     virtual void set_delayed(bool delayed)
     {
       right()->set_delayed(delayed);
@@ -1447,6 +1473,9 @@ namespace Sass {
     { concrete_type(STRING); }
     static std::string type_name() { return "string"; }
     virtual ~String() = 0;
+    virtual void rtrim() = 0;
+    virtual void ltrim() = 0;
+    virtual void trim() = 0;
     virtual bool operator==(const Expression& rhs) const = 0;
     ATTACH_OPERATIONS()
   };
@@ -1475,6 +1504,9 @@ namespace Sass {
       }
       return false;
     }
+    virtual void rtrim();
+    virtual void ltrim();
+    virtual void trim();
 
     virtual size_t hash()
     {
@@ -1515,6 +1547,9 @@ namespace Sass {
     std::string type() { return "string"; }
     static std::string type_name() { return "string"; }
     virtual bool is_invisible() const;
+    virtual void rtrim();
+    virtual void ltrim();
+    virtual void trim();
 
     virtual size_t hash()
     {
@@ -1672,42 +1707,15 @@ namespace Sass {
   /////////////////////////////////////////////////
   // At root expressions (for use inside @at-root).
   /////////////////////////////////////////////////
-  class At_Root_Expression : public Expression {
+  class At_Root_Query : public Expression {
   private:
-    ADD_PROPERTY(String*, feature)
+    ADD_PROPERTY(Expression*, feature)
     ADD_PROPERTY(Expression*, value)
-    ADD_PROPERTY(bool, is_interpolated)
   public:
-    At_Root_Expression(ParserState pstate, String* f = 0, Expression* v = 0, bool i = false)
-    : Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
+    At_Root_Query(ParserState pstate, Expression* f = 0, Expression* v = 0, bool i = false)
+    : Expression(pstate), feature_(f), value_(v)
     { }
-    bool exclude(std::string str)
-    {
-      bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
-      List* l = static_cast<List*>(value());
-      std::string v;
-
-      if (with)
-      {
-        if (!l || l->length() == 0) return str.compare("rule") != 0;
-        for (size_t i = 0, L = l->length(); i < L; ++i)
-        {
-          v = unquote((*l)[i]->to_string());
-          if (v.compare("all") == 0 || v == str) return false;
-        }
-        return true;
-      }
-      else
-      {
-        if (!l || !l->length()) return str.compare("rule") == 0;
-        for (size_t i = 0, L = l->length(); i < L; ++i)
-        {
-          v = unquote((*l)[i]->to_string());
-          if (v.compare("all") == 0 || v == str) return true;
-        }
-        return false;
-      }
-    }
+    bool exclude(std::string str);
     ATTACH_OPERATIONS()
   };
 
@@ -1715,9 +1723,9 @@ namespace Sass {
   // At-root.
   ///////////
   class At_Root_Block : public Has_Block {
-    ADD_PROPERTY(At_Root_Expression*, expression)
+    ADD_PROPERTY(At_Root_Query*, expression)
   public:
-    At_Root_Block(ParserState pstate, Block* b = 0, At_Root_Expression* e = 0)
+    At_Root_Block(ParserState pstate, Block* b = 0, At_Root_Query* e = 0)
     : Has_Block(pstate, b), expression_(e)
     { statement_type(ATROOT); }
     bool is_hoistable() { return true; }
@@ -1725,7 +1733,7 @@ namespace Sass {
     bool exclude_node(Statement* s) {
       if (s->statement_type() == Statement::DIRECTIVE)
       {
-        return expression()->exclude(static_cast<At_Rule*>(s)->keyword().erase(0, 1));
+        return expression()->exclude(static_cast<Directive*>(s)->keyword().erase(0, 1));
       }
       if (s->statement_type() == Statement::MEDIA)
       {
@@ -1739,7 +1747,7 @@ namespace Sass {
       {
         return expression()->exclude("supports");
       }
-      if (static_cast<At_Rule*>(s)->is_keyframes())
+      if (static_cast<Directive*>(s)->is_keyframes())
       {
         return expression()->exclude("keyframes");
       }
@@ -1878,6 +1886,9 @@ namespace Sass {
     virtual unsigned long specificity() {
       return Constants::Specificity_Universal;
     }
+    virtual void set_media_block(Media_Block* mb) {
+      media_block(mb);
+    }
   };
   inline Selector::~Selector() { }
 
@@ -1892,6 +1903,7 @@ namespace Sass {
     Selector_Schema(ParserState pstate, String* c)
     : Selector(pstate), contents_(c), at_root_(false)
     { }
+    virtual bool has_parent_ref();
     virtual size_t hash() {
       if (hash_ == 0) {
         hash_combine(hash_, contents_->hash());
@@ -2140,6 +2152,10 @@ namespace Sass {
         return Constants::Specificity_Type;
       return Constants::Specificity_Pseudo;
     }
+    bool operator==(const Simple_Selector& rhs) const;
+    bool operator==(const Pseudo_Selector& rhs) const;
+    bool operator<(const Simple_Selector& rhs) const;
+    bool operator<(const Pseudo_Selector& rhs) const;
     virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
     ATTACH_OPERATIONS()
   };
@@ -2377,6 +2393,11 @@ namespace Sass {
       if (tail()) sum += tail()->specificity();
       return sum;
     }
+    virtual void set_media_block(Media_Block* mb) {
+      media_block(mb);
+      if (tail_) tail_->set_media_block(mb);
+      if (head_) head_->set_media_block(mb);
+    }
     bool operator<(const Complex_Selector& rhs) const;
     bool operator==(const Complex_Selector& rhs) const;
     inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }
@@ -2479,6 +2500,12 @@ namespace Sass {
       }
       return sum;
     }
+    virtual void set_media_block(Media_Block* mb) {
+      media_block(mb);
+      for (Complex_Selector* cs : elements()) {
+        cs->set_media_block(mb);
+      }
+    }
     Selector_List* clone(Context&) const;      // does not clone Compound_Selector*s
     Selector_List* cloneFully(Context&) const; // clones Compound_Selector*s
     virtual bool operator==(const Selector& rhs) const;

data/ext/libsass/src/ast_factory.hpp

@@ -17,7 +17,7 @@ namespace Sass {
     Supports_Query* new_Supports_Query(std::string p, size_t l, Supports_Query* f, Block* b);
     Media_Query* new_Media_Query(std::string p, size_t l, List* q, Block* b);
     At_Root_Block* new_At_Root_Block(std::string p, size_t l, Selector* sel, Block* b);
-    At_Rule* new_At_Rule(std::string p, size_t l, std::string kwd, Selector* sel, Block* b);
+    Directive* new_At_Rule(std::string p, size_t l, std::string kwd, Selector* sel, Block* b);
     Keyframe_Rule* new_Keyframe_Rule(std::string p, size_t l, Block* b);
     Declaration* new_Declaration(std::string p, size_t l, String* prop, List* vals);
     Assignment* new_Assignment(std::string p, size_t l, std::string var, Expression* val, bool guarded = false);

data/ext/libsass/src/ast_fwd_decl.hpp

@@ -15,7 +15,7 @@ namespace Sass {
   class Bubble;
   class Media_Block;
   class Supports_Block;
-  class At_Rule;
+  class Directive;
   class Keyframe_Rule;
   class At_Root_Block;
   class Declaration;
@@ -62,7 +62,7 @@ namespace Sass {
   class Supports_Negation;
   class Supports_Declaration;
   class Supports_Interpolation;
-  class At_Root_Expression;
+  class At_Root_Query;
   class Null;
   class Parent_Selector;
   // parameters and arguments

data/ext/libsass/src/constants.cpp

@@ -88,10 +88,8 @@ namespace Sass {
     extern const char progid_kwd[]       = "progid";
     extern const char expression_kwd[]   = "expression";
     extern const char calc_fn_kwd[]      = "calc";
-    extern const char calc_kwd[]         = "calc(";
-    extern const char moz_calc_kwd[]     = "-moz-calc(";
-    extern const char webkit_calc_kwd[]  = "-webkit-calc(";
-    extern const char ms_calc_kwd[]      = "-ms-calc(";
+
+    extern const char almost_any_value_class[] = "\"'#!;{}";
 
     // css selector keywords
     extern const char sel_deep_kwd[] = "/deep/";

data/ext/libsass/src/constants.hpp

@@ -87,11 +87,10 @@ namespace Sass {
     extern const char odd_kwd[];
     extern const char progid_kwd[];
     extern const char expression_kwd[];
-    extern const char calc_kwd[];
     extern const char calc_fn_kwd[];
-    extern const char moz_calc_kwd[];
-    extern const char webkit_calc_kwd[];
-    extern const char ms_calc_kwd[];
+
+    // char classes for "regular expressions"
+    extern const char almost_any_value_class[];
 
     // css selector keywords
     extern const char sel_deep_kwd[];

data/ext/libsass/src/context.cpp

@@ -92,9 +92,9 @@ namespace Sass {
 
     // collect more paths from different options
     collect_include_paths(c_options.include_path);
-    // collect_include_paths(c_options.include_paths);
+    collect_include_paths(c_options.include_paths);
     collect_plugin_paths(c_options.plugin_path);
-    // collect_plugin_paths(c_options.plugin_paths);
+    collect_plugin_paths(c_options.plugin_paths);
 
     // load plugins and register custom behaviors
     for(auto plug : plugin_paths) plugins.load_plugins(plug);
@@ -162,7 +162,6 @@ namespace Sass {
 
   void Context::collect_include_paths(const char* paths_str)
   {
-
     if (paths_str) {
       const char* beg = paths_str;
       const char* end = Prelexer::find_first<PATH_SEP>(beg);
@@ -185,17 +184,17 @@ namespace Sass {
     }
   }
 
-  void Context::collect_include_paths(const char** paths_array)
+  void Context::collect_include_paths(string_list* paths_array)
   {
-    if (!paths_array) return;
-    for (size_t i = 0; paths_array[i]; i++) {
-      collect_include_paths(paths_array[i]);
+    while (paths_array)
+    {
+      collect_include_paths(paths_array->string);
+      paths_array = paths_array->next;
     }
   }
 
   void Context::collect_plugin_paths(const char* paths_str)
   {
-
     if (paths_str) {
       const char* beg = paths_str;
       const char* end = Prelexer::find_first<PATH_SEP>(beg);
@@ -218,15 +217,15 @@ namespace Sass {
     }
   }
 
-  void Context::collect_plugin_paths(const char** paths_array)
+  void Context::collect_plugin_paths(string_list* paths_array)
   {
-    if (!paths_array) return;
-    for (size_t i = 0; paths_array[i]; i++) {
-      collect_plugin_paths(paths_array[i]);
+    while (paths_array)
+    {
+      collect_plugin_paths(paths_array->string);
+      paths_array = paths_array->next;
     }
   }
 
-
   // resolve the imp_path in base_path or include_paths
   // looks for alternatives and returns a list from one directory
   std::vector<Include> Context::find_includes(const Importer& import)
@@ -289,7 +288,7 @@ namespace Sass {
     const char* contents = resources[idx].contents;
     // keep a copy of the path around (for parserstates)
     // ToDo: we clean it, but still not very elegant!?
-    strings.push_back(sass_strdup(inc.abs_path.c_str()));
+    strings.push_back(sass_copy_c_string(inc.abs_path.c_str()));
     // create the initial parser state from resource
     ParserState pstate(strings.back(), contents, idx);
 
@@ -519,7 +518,7 @@ namespace Sass {
     }
     // create a copy of the resulting buffer string
     // this must be freed or taken over by implementor
-    return sass_strdup(emitted.buffer.c_str());
+    return sass_copy_c_string(emitted.buffer.c_str());
   }
 
   void Context::apply_custom_headers(Block* root, const char* ctx_path, ParserState pstate)
@@ -606,7 +605,7 @@ namespace Sass {
 
     // ToDo: this may be resolved via custom importers
     std::string abs_path(rel2abs(entry_path));
-    char* abs_path_c_str = sass_strdup(abs_path.c_str());
+    char* abs_path_c_str = sass_copy_c_string(abs_path.c_str());
     strings.push_back(abs_path_c_str);
 
     // create entry only for the import stack
@@ -693,7 +692,7 @@ namespace Sass {
     if (source_map_file == "") return 0;
     char* result = 0;
     std::string map = emitter.render_srcmap(*this);
-    result = sass_strdup(map.c_str());
+    result = sass_copy_c_string(map.c_str());
     return result;
   }
 

data/ext/libsass/src/context.hpp

@@ -101,9 +101,9 @@ namespace Sass {
 
   private:
     void collect_plugin_paths(const char* paths_str);
-    void collect_plugin_paths(const char** paths_array);
+    void collect_plugin_paths(string_list* paths_array);
     void collect_include_paths(const char* paths_str);
-    void collect_include_paths(const char** paths_array);
+    void collect_include_paths(string_list* paths_array);
     std::string format_embedded_source_map();
     std::string format_source_mapping_url(const std::string& out_path);
 

data/ext/libsass/src/cssize.cpp

@@ -13,14 +13,22 @@ namespace Sass {
   : ctx(ctx),
     block_stack(std::vector<Block*>()),
     p_stack(std::vector<Statement*>()),
+    s_stack(std::vector<Selector_List*>()),
     backtrace(bt)
-  {  }
+  {
+    s_stack.push_back(NULL);
+  }
 
   Statement* Cssize::parent()
   {
     return p_stack.size() ? p_stack.back() : block_stack.front();
   }
 
+  Selector_List* Cssize::selector()
+  {
+    return s_stack.size() ? s_stack.back() : NULL;
+  }
+
   Statement* Cssize::operator()(Block* b)
   {
     Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, b->pstate(), b->length(), b->is_root());
@@ -31,7 +39,7 @@ namespace Sass {
     return bb;
   }
 
-  Statement* Cssize::operator()(At_Rule* r)
+  Statement* Cssize::operator()(Directive* r)
   {
     if (!r->block() || !r->block()->length()) return r;
 
@@ -41,7 +49,7 @@ namespace Sass {
     }
 
     p_stack.push_back(r);
-    At_Rule* rr = SASS_MEMORY_NEW(ctx.mem, At_Rule,
+    Directive* rr = SASS_MEMORY_NEW(ctx.mem, Directive,
                                   r->pstate(),
                                   r->keyword(),
                                   r->selector(),
@@ -57,7 +65,7 @@ namespace Sass {
       else {
         s = static_cast<Bubble*>(s)->node();
         if (s->statement_type() != Statement::DIRECTIVE) directive_exists = false;
-        else directive_exists = (static_cast<At_Rule*>(s)->keyword() == rr->keyword());
+        else directive_exists = (static_cast<Directive*>(s)->keyword() == rr->keyword());
       }
 
     }
@@ -65,7 +73,7 @@ namespace Sass {
     Block* result = SASS_MEMORY_NEW(ctx.mem, Block, rr->pstate());
     if (!(directive_exists || rr->is_keyframes()))
     {
-      At_Rule* empty_node = static_cast<At_Rule*>(rr);
+      Directive* empty_node = static_cast<Directive*>(rr);
       empty_node->block(SASS_MEMORY_NEW(ctx.mem, Block, rr->block() ? rr->block()->pstate() : rr->pstate()));
       *result << empty_node;
     }
@@ -93,11 +101,14 @@ namespace Sass {
   Statement* Cssize::operator()(Ruleset* r)
   {
     p_stack.push_back(r);
+    s_stack.push_back(dynamic_cast<Selector_List*>(r->selector()));
     Ruleset* rr = SASS_MEMORY_NEW(ctx.mem, Ruleset,
                                   r->pstate(),
                                   r->selector(),
                                   r->block()->perform(this)->block());
+    rr->is_root(r->is_root());
     // rr->tabs(r->block()->tabs());
+    s_stack.pop_back();
     p_stack.pop_back();
 
     if (!rr->block()) {
@@ -213,7 +224,7 @@ namespace Sass {
     return bubble(m);
   }
 
-  Statement* Cssize::bubble(At_Rule* m)
+  Statement* Cssize::bubble(Directive* m)
   {
     Block* bb = SASS_MEMORY_NEW(ctx.mem, Block, this->parent()->pstate());
     Has_Block* new_rule = static_cast<Has_Block*>(shallow_copy(this->parent()));
@@ -227,7 +238,7 @@ namespace Sass {
 
     Block* wrapper_block = SASS_MEMORY_NEW(ctx.mem, Block, m->block() ? m->block()->pstate() : m->pstate());
     *wrapper_block << new_rule;
-    At_Rule* mm = SASS_MEMORY_NEW(ctx.mem, At_Rule,
+    Directive* mm = SASS_MEMORY_NEW(ctx.mem, Directive,
                                   m->pstate(),
                                   m->keyword(),
                                   m->selector(),
@@ -374,7 +385,7 @@ namespace Sass {
       case Statement::BUBBLE:
         return SASS_MEMORY_NEW(ctx.mem, Bubble, *static_cast<Bubble*>(s));
       case Statement::DIRECTIVE:
-        return SASS_MEMORY_NEW(ctx.mem, At_Rule, *static_cast<At_Rule*>(s));
+        return SASS_MEMORY_NEW(ctx.mem, Directive, *static_cast<Directive*>(s));
       case Statement::SUPPORTS:
         return SASS_MEMORY_NEW(ctx.mem, Supports_Block, *static_cast<Supports_Block*>(s));
       case Statement::ATROOT: