sassc 2.2.1 → 2.3.0

data/ext/libsass/src/emitter.cpp

@@ -1,10 +1,9 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-#include "util.hpp"
-#include "context.hpp"
-#include "output.hpp"
 #include "emitter.hpp"
 #include "util_string.hpp"
-#include "utf8_string.hpp"
+#include "util.hpp"
 
 namespace Sass {
 

data/ext/libsass/src/emitter.hpp

@@ -5,8 +5,6 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <string>
-
 #include "sass/base.h"
 #include "source_map.hpp"
 #include "ast_fwd_decl.hpp"

data/ext/libsass/src/environment.hpp

@@ -1,6 +1,11 @@
 #ifndef SASS_ENVIRONMENT_H
 #define SASS_ENVIRONMENT_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <map>
 #include <string>
 #include "ast_fwd_decl.hpp"
 #include "ast_def_macros.hpp"

data/ext/libsass/src/error_handling.cpp

@@ -132,6 +132,27 @@ namespace Sass {
       prefix = err.errtype();
     }
 
+    TopLevelParent::TopLevelParent(Backtraces traces, ParserState pstate)
+      : Base(pstate, "Top-level selectors may not contain the parent selector \"&\".", traces)
+    {
+
+    }
+
+    UnsatisfiedExtend::UnsatisfiedExtend(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "The target selector was not found.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+
+    ExtendAcrossMedia::ExtendAcrossMedia(Backtraces traces, Extension extension)
+      : Base(extension.target->pstate(), "You may not @extend selectors across media queries.\n"
+        "Use \"@extend " + extension.target->to_string() + " !optional\" to avoid this error.", traces)
+    {
+
+    }
+    
+
   }
 
 

data/ext/libsass/src/error_handling.hpp

@@ -1,6 +1,10 @@
 #ifndef SASS_ERROR_HANDLING_H
 #define SASS_ERROR_HANDLING_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include <string>
 #include <sstream>
 #include <stdexcept>
@@ -205,9 +209,27 @@ namespace Sass {
     };
 
     class SassValueError : public Base {
-      public:
-        SassValueError(Backtraces traces, ParserState pstate, OperationError& err);
-        virtual ~SassValueError() throw() {};
+    public:
+      SassValueError(Backtraces traces, ParserState pstate, OperationError& err);
+      virtual ~SassValueError() throw() {};
+    };
+
+    class TopLevelParent : public Base {
+    public:
+      TopLevelParent(Backtraces traces, ParserState pstate);
+      virtual ~TopLevelParent() throw() {};
+    };
+
+    class UnsatisfiedExtend : public Base {
+    public:
+      UnsatisfiedExtend(Backtraces traces, Extension extension);
+      virtual ~UnsatisfiedExtend() throw() {};
+    };
+
+    class ExtendAcrossMedia : public Base {
+    public:
+      ExtendAcrossMedia(Backtraces traces, Extension extension);
+      virtual ~ExtendAcrossMedia() throw() {};
     };
 
   }

data/ext/libsass/src/eval.cpp

@@ -72,28 +72,11 @@ namespace Sass {
     return exp.env_stack;
   }
 
-  Selector_List_Obj Eval::selector()
-  {
-    return exp.selector();
-  }
-
   std::vector<Sass_Callee>& Eval::callee_stack()
   {
     return ctx.callee_stack;
   }
 
-
-  SelectorStack& Eval::selector_stack()
-  {
-    return exp.selector_stack;
-  }
-
-  bool& Eval::old_at_root_without_rule()
-  {
-    return exp.old_at_root_without_rule;
-  }
-
-
   Expression* Eval::operator()(Block* b)
   {
     Expression* val = 0;
@@ -251,9 +234,8 @@ namespace Sass {
     if (expr->concrete_type() == Expression::MAP) {
       map = Cast<Map>(expr);
     }
-    else if (Selector_List* ls = Cast<Selector_List>(expr)) {
-      Listize listize;
-      Expression_Obj rv = ls->perform(&listize);
+    else if (SelectorList * ls = Cast<SelectorList>(expr)) {
+      Expression_Obj rv = Listize::perform(ls);
       list = Cast<List>(rv);
     }
     else if (expr->concrete_type() != Expression::LIST) {
@@ -286,7 +268,7 @@ namespace Sass {
       }
     }
     else {
-      if (list->length() == 1 && Cast<Selector_List>(list)) {
+      if (list->length() == 1 && Cast<SelectorList>(list)) {
         list = Cast<List>(list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
@@ -490,6 +472,7 @@ namespace Sass {
     return 0;
   }
 
+
   Expression* Eval::operator()(List* l)
   {
     // special case for unevaluated map
@@ -707,9 +690,9 @@ namespace Sass {
                                                     b->op(), s_l->last(), b->right());
         bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // unverified
         for (size_t i = 0; i < s_l->length() - 1; ++i) {
-          ret_schema->append(Cast<PreValue>(s_l->at(i)->perform(this)));
+          ret_schema->append(s_l->at(i)->perform(this));
         }
-        ret_schema->append(Cast<PreValue>(bin_ex->perform(this)));
+        ret_schema->append(bin_ex->perform(this));
         return ret_schema->perform(this);
       }
     }
@@ -720,9 +703,9 @@ namespace Sass {
         Binary_Expression_Obj bin_ex = SASS_MEMORY_NEW(Binary_Expression, b->pstate(),
                                                     b->op(), b->left(), s_r->first());
         bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // verified
-        ret_schema->append(Cast<PreValue>(bin_ex->perform(this)));
+        ret_schema->append(bin_ex->perform(this));
         for (size_t i = 1; i < s_r->length(); ++i) {
-          ret_schema->append(Cast<PreValue>(s_r->at(i)->perform(this)));
+          ret_schema->append(s_r->at(i)->perform(this));
         }
         return ret_schema->perform(this);
       }
@@ -933,7 +916,7 @@ namespace Sass {
       return nr.detach();
     }
     else {
-      // Special cases: +/- variables which evaluate to null ouput just +/-,
+      // Special cases: +/- variables which evaluate to null output just +/-,
       // but +/- null itself outputs the string
       if (operand->concrete_type() == Expression::NULL_VAL && Cast<Variable>(u->operand())) {
         u->operand(SASS_MEMORY_NEW(String_Quoted, u->pstate(), ""));
@@ -942,12 +925,19 @@ namespace Sass {
       else if (Color* color = Cast<Color>(operand)) {
         // Use the color name if this was eval with one
         if (color->disp().length() > 0) {
-          operand = SASS_MEMORY_NEW(String_Constant, operand->pstate(), color->disp());
-          u->operand(operand);
+          Unary_Expression_Obj cpy = SASS_MEMORY_COPY(u);
+          cpy->operand(SASS_MEMORY_NEW(String_Constant, operand->pstate(), color->disp()));
+          return SASS_MEMORY_NEW(String_Quoted,
+                                 cpy->pstate(),
+                                 cpy->inspect());
         }
       }
       else {
-        u->operand(operand);
+        Unary_Expression_Obj cpy = SASS_MEMORY_COPY(u);
+        cpy->operand(operand);
+        return SASS_MEMORY_NEW(String_Quoted,
+                               cpy->pstate(),
+                               cpy->inspect());
       }
 
       return SASS_MEMORY_NEW(String_Quoted,
@@ -995,7 +985,7 @@ namespace Sass {
                                              c->name(),
                                              args);
         if (args->has_named_arguments()) {
-          error("Function " + c->name() + " doesn't support keyword arguments", c->pstate(), traces);
+          error("Plain CSS function " + c->name() + " doesn't support keyword arguments", c->pstate(), traces);
         }
         String_Quoted* str = SASS_MEMORY_NEW(String_Quoted,
                                              c->pstate(),
@@ -1065,7 +1055,7 @@ namespace Sass {
         result = body->perform(this);
       }
       else if (func) {
-        result = func(fn_env, *env, ctx, def->signature(), c->pstate(), traces, exp.selector_stack);
+        result = func(fn_env, *env, ctx, def->signature(), c->pstate(), traces, exp.getSelectorStack(), exp.originalStack);
       }
       if (!result) {
         error(std::string("Function ") + c->name() + " finished without @return", c->pstate(), traces);
@@ -1214,11 +1204,6 @@ namespace Sass {
 
     if (Cast<Null>(ex)) { return; }
 
-    // parent selector needs another go
-    if (Cast<Parent_Selector>(ex)) {
-      // XXX: this is never hit via spec tests
-      ex = ex->perform(this);
-    }
     // parent selector needs another go
     if (Cast<Parent_Reference>(ex)) {
       // XXX: this is never hit via spec tests
@@ -1254,7 +1239,6 @@ namespace Sass {
     // Selector_List
     // String_Quoted
     // String_Constant
-    // Parent_Selector
     // Binary_Expression
     else {
       // ex = ex->perform(this);
@@ -1512,69 +1496,7 @@ namespace Sass {
     return 0;
   }
 
-  Selector_List* Eval::operator()(Selector_List* s)
-  {
-    SelectorStack rv;
-    Selector_List_Obj sl = SASS_MEMORY_NEW(Selector_List, s->pstate());
-    sl->is_optional(s->is_optional());
-    sl->media_block(s->media_block());
-    sl->is_optional(s->is_optional());
-    for (size_t i = 0, iL = s->length(); i < iL; ++i) {
-      rv.push_back(operator()((*s)[i]));
-    }
-
-    // we should actually permutate parent first
-    // but here we have permutated the selector first
-    size_t round = 0;
-    while (round != std::string::npos) {
-      bool abort = true;
-      for (size_t i = 0, iL = rv.size(); i < iL; ++i) {
-        if (rv[i]->length() > round) {
-          sl->append((*rv[i])[round]);
-          abort = false;
-        }
-      }
-      if (abort) {
-        round = std::string::npos;
-      } else {
-        ++ round;
-      }
-
-    }
-    return sl.detach();
-  }
-
-
-  Selector_List* Eval::operator()(Complex_Selector* s)
-  {
-    bool implicit_parent = !exp.old_at_root_without_rule;
-    if (is_in_selector_schema) exp.selector_stack.push_back({});
-    Selector_List_Obj resolved = s->resolve_parent_refs(exp.selector_stack, traces, implicit_parent);
-    if (is_in_selector_schema) exp.selector_stack.pop_back();
-    for (size_t i = 0; i < resolved->length(); i++) {
-      Complex_Selector* is = resolved->at(i)->mutable_first();
-      while (is) {
-        if (is->head()) {
-          is->head(operator()(is->head()));
-        }
-        is = is->tail();
-      }
-    }
-    return resolved.detach();
-  }
-
-  Compound_Selector* Eval::operator()(Compound_Selector* s)
-  {
-    for (size_t i = 0; i < s->length(); i++) {
-      Simple_Selector* ss = s->at(i);
-      // skip parents here (called via resolve_parent_refs)
-      if (ss == NULL || Cast<Parent_Selector>(ss)) continue;
-      s->at(i) = Cast<Simple_Selector>(ss->perform(this));
-    }
-    return s;
-  }
-
-  Selector_List* Eval::operator()(Selector_Schema* s)
+  SelectorList* Eval::operator()(Selector_Schema* s)
   {
     LOCAL_FLAG(is_in_selector_schema, true);
     // the parser will look for a brace to end the selector
@@ -1584,74 +1506,32 @@ namespace Sass {
     char* temp_cstr = sass_copy_c_string(result_str.c_str());
     ctx.strings.push_back(temp_cstr); // attach to context
     Parser p = Parser::from_c_str(temp_cstr, ctx, traces, s->pstate());
-    p.last_media_block = s->media_block();
-    // a selector schema may or may not connect to parent?
-    bool chroot = s->connect_parent() == false;
-    Selector_List_Obj sl = p.parse_selector_list(chroot);
-    flag_is_in_selector_schema.reset();
-    return operator()(sl);
-  }
 
-  Expression* Eval::operator()(Parent_Selector* p)
-  {
-    if (Selector_List_Obj pr = selector()) {
-      exp.selector_stack.pop_back();
-      Selector_List_Obj rv = operator()(pr);
-      exp.selector_stack.push_back(rv);
-      return rv.detach();
-    } else {
-      return SASS_MEMORY_NEW(Null, p->pstate());
-    }
+    // If a schema contains a reference to parent it is already
+    // connected to it, so don't connect implicitly anymore
+    SelectorListObj parsed = p.parseSelectorList(true);
+    flag_is_in_selector_schema.reset();
+    return parsed.detach();
   }
 
   Expression* Eval::operator()(Parent_Reference* p)
   {
-    if (Selector_List_Obj pr = selector()) {
-      exp.selector_stack.pop_back();
-      Selector_List_Obj rv = operator()(pr);
-      exp.selector_stack.push_back(rv);
-      return rv.detach();
+    if (SelectorListObj pr = exp.original()) {
+      return operator()(pr);
     } else {
       return SASS_MEMORY_NEW(Null, p->pstate());
     }
   }
 
-  Simple_Selector* Eval::operator()(Simple_Selector* s)
+  SimpleSelector* Eval::operator()(SimpleSelector* s)
   {
     return s;
   }
 
-  // hotfix to avoid invalid nested `:not` selectors
-  // probably the wrong place, but this should ultimately
-  // be fixed by implement superselector correctly for `:not`
-  // first use of "find" (ATM only implemented for selectors)
-  bool hasNotSelector(AST_Node_Obj obj) {
-    if (Wrapped_Selector* w = Cast<Wrapped_Selector>(obj)) {
-      return w->name() == ":not";
-    }
-    return false;
-  }
-
-  Wrapped_Selector* Eval::operator()(Wrapped_Selector* s)
+  Pseudo_Selector* Eval::operator()(Pseudo_Selector* pseudo)
   {
-
-    if (s->name() == ":not") {
-      if (exp.selector_stack.back()) {
-        if (s->selector()->find(hasNotSelector)) {
-          s->selector()->clear();
-          s->name(" ");
-        } else {
-          for (size_t i = 0; i < s->selector()->length(); ++i) {
-            Complex_Selector* cs = s->selector()->at(i);
-            if (cs->tail()) {
-              s->selector()->clear();
-              s->name(" ");
-            }
-          }
-        }
-      }
-    }
-    return s;
+    // ToDo: should we eval selector?
+    return pseudo;
   };
 
 }

data/ext/libsass/src/eval.hpp

@@ -1,7 +1,11 @@
 #ifndef SASS_EVAL_H
 #define SASS_EVAL_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
 #include "ast.hpp"
+
 #include "context.hpp"
 #include "listize.hpp"
 #include "operation.hpp"
@@ -31,12 +35,8 @@ namespace Sass {
     Env* environment();
     EnvStack& env_stack();
     const std::string cwd();
-    Selector_List_Obj selector();
     CalleeStack& callee_stack();
-    SelectorStack& selector_stack();
-    bool& old_at_root_without_rule();
     struct Sass_Inspect_Options& options();
-    struct Sass_Inspect_Options options2();
     struct Sass_Compiler* compiler();
 
     // for evaluating function bodies
@@ -64,7 +64,6 @@ namespace Sass {
     Expression* operator()(String_Schema*);
     Expression* operator()(String_Quoted*);
     Expression* operator()(String_Constant*);
-    // Expression* operator()(Selector_List*);
     Media_Query* operator()(Media_Query*);
     Expression* operator()(Media_Query_Expression*);
     Expression* operator()(At_Root_Query*);
@@ -78,23 +77,22 @@ namespace Sass {
     Expression* operator()(Comment*);
 
     // these will return selectors
-    Selector_List* operator()(Selector_List*);
-    Selector_List* operator()(Complex_Selector*);
-    Compound_Selector* operator()(Compound_Selector*);
-    Simple_Selector* operator()(Simple_Selector* s);
-    Wrapped_Selector* operator()(Wrapped_Selector* s);
+    SelectorList* operator()(SelectorList*);
+    SelectorList* operator()(ComplexSelector*);
+    CompoundSelector* operator()(CompoundSelector*);
+    SelectorComponent* operator()(SelectorComponent*);
+    SimpleSelector* operator()(SimpleSelector* s);
+    Pseudo_Selector* operator()(Pseudo_Selector* s);
 
     // they don't have any specific implementation (yet)
     Id_Selector* operator()(Id_Selector* s) { return s; };
     Class_Selector* operator()(Class_Selector* s) { return s; };
-    Pseudo_Selector* operator()(Pseudo_Selector* s) { return s; };
     Type_Selector* operator()(Type_Selector* s) { return s; };
     Attribute_Selector* operator()(Attribute_Selector* s) { return s; };
     Placeholder_Selector* operator()(Placeholder_Selector* s) { return s; };
 
     // actual evaluated selectors
-    Selector_List* operator()(Selector_Schema*);
-    Expression* operator()(Parent_Selector*);
+    SelectorList* operator()(Selector_Schema*);
     Expression* operator()(Parent_Reference*);
 
     // generic fallback