sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/fn_numbers.hpp

@@ -0,0 +1,45 @@
+#ifndef SASS_FN_NUMBERS_H
+#define SASS_FN_NUMBERS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    // return a number object (copied since we want to have reduced units)
+    #define ARGN(argname) get_arg_n(argname, env, sig, pstate, traces) // Number copy
+
+    extern Signature percentage_sig;
+    extern Signature round_sig;
+    extern Signature ceil_sig;
+    extern Signature floor_sig;
+    extern Signature abs_sig;
+    extern Signature min_sig;
+    extern Signature max_sig;
+    extern Signature inspect_sig;
+    extern Signature random_sig;
+    extern Signature unique_id_sig;
+    extern Signature unit_sig;
+    extern Signature unitless_sig;
+    extern Signature comparable_sig;
+
+    BUILT_IN(percentage);
+    BUILT_IN(round);
+    BUILT_IN(ceil);
+    BUILT_IN(floor);
+    BUILT_IN(abs);
+    BUILT_IN(min);
+    BUILT_IN(max);
+    BUILT_IN(inspect);
+    BUILT_IN(random);
+    BUILT_IN(unique_id);
+    BUILT_IN(unit);
+    BUILT_IN(unitless);
+    BUILT_IN(comparable);
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/fn_selectors.cpp

@@ -0,0 +1,235 @@
+#include "parser.hpp"
+#include "extend.hpp"
+#include "fn_utils.hpp"
+#include "fn_selectors.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    Signature selector_nest_sig = "selector-nest($selectors...)";
+    BUILT_IN(selector_nest)
+    {
+      List* arglist = ARG("$selectors", List);
+
+      // Not enough parameters
+      if( arglist->length() == 0 )
+        error("$selectors: At least one selector must be passed for `selector-nest'", pstate, traces);
+
+      // Parse args into vector of selectors
+      SelectorStack parsedSelectors;
+      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
+        if (exp->concrete_type() == Expression::NULL_VAL) {
+          std::stringstream msg;
+          msg << "$selectors: null is not a valid selector: it must be a string,\n";
+          msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
+          error(msg.str(), pstate, traces);
+        }
+        if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
+          str->quote_mark(0);
+        }
+        std::string exp_src = exp->to_string(ctx.c_options);
+        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+        parsedSelectors.push_back(sel);
+      }
+
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(Null, pstate);
+      }
+
+      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
+      SelectorStack::iterator itr = parsedSelectors.begin();
+      Selector_List_Obj result = *itr;
+      ++itr;
+
+      for(;itr != parsedSelectors.end(); ++itr) {
+        Selector_List_Obj child = *itr;
+        std::vector<Complex_Selector_Obj> exploded;
+        selector_stack.push_back(result);
+        Selector_List_Obj rv = child->resolve_parent_refs(selector_stack, traces);
+        selector_stack.pop_back();
+        for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
+          exploded.push_back((*rv)[m]);
+        }
+        result->elements(exploded);
+      }
+
+      Listize listize;
+      return Cast<Value>(result->perform(&listize));
+    }
+
+    Signature selector_append_sig = "selector-append($selectors...)";
+    BUILT_IN(selector_append)
+    {
+      List* arglist = ARG("$selectors", List);
+
+      // Not enough parameters
+      if( arglist->length() == 0 )
+        error("$selectors: At least one selector must be passed for `selector-append'", pstate, traces);
+
+      // Parse args into vector of selectors
+      SelectorStack parsedSelectors;
+      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
+        if (exp->concrete_type() == Expression::NULL_VAL) {
+          std::stringstream msg;
+          msg << "$selectors: null is not a valid selector: it must be a string,\n";
+          msg << "a list of strings, or a list of lists of strings for 'selector-append'";
+          error(msg.str(), pstate, traces);
+        }
+        if (String_Constant* str = Cast<String_Constant>(exp)) {
+          str->quote_mark(0);
+        }
+        std::string exp_src = exp->to_string();
+        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces,
+                                                       exp->pstate(), pstate.src,
+                                                       /*allow_parent=*/false);
+
+        parsedSelectors.push_back(sel);
+      }
+
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(Null, pstate);
+      }
+
+      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
+      SelectorStack::iterator itr = parsedSelectors.begin();
+      Selector_List_Obj result = *itr;
+      ++itr;
+
+      for(;itr != parsedSelectors.end(); ++itr) {
+        Selector_List_Obj child = *itr;
+        std::vector<Complex_Selector_Obj> newElements;
+
+        // For every COMPLEX_SELECTOR in `result`
+        // For every COMPLEX_SELECTOR in `child`
+          // let parentSeqClone equal a copy of result->elements[i]
+          // let childSeq equal child->elements[j]
+          // Append all of childSeq head elements into parentSeqClone
+          // Set the innermost tail of parentSeqClone, to childSeq's tail
+        // Replace result->elements with newElements
+        for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {
+          for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {
+            Complex_Selector_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);
+            Complex_Selector_Obj childSeq = (*child)[j];
+            Complex_Selector_Obj base = childSeq->tail();
+
+            // Must be a simple sequence
+            if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
+              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
+                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
+            }
+
+            // Cannot be a Universal selector
+            Type_Selector_Obj pType = Cast<Type_Selector>(childSeq->head()->first());
+            if(pType && pType->name() == "*") {
+              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
+                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
+            }
+
+            // TODO: Add check for namespace stuff
+
+            Complex_Selector* lastComponent = parentSeqClone->mutable_last();
+            if (lastComponent->head() == nullptr) {
+              std::string msg = "Parent \"" + parentSeqClone->to_string() + "\" is incompatible with \"" + base->to_string() + "\"";
+              error(msg, pstate, traces);
+            }
+            lastComponent->head()->concat(base->head());
+            lastComponent->tail(base->tail());
+
+            newElements.push_back(parentSeqClone);
+          }
+        }
+
+        result->elements(newElements);
+      }
+
+      Listize listize;
+      return Cast<Value>(result->perform(&listize));
+    }
+
+    Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
+    BUILT_IN(selector_unify)
+    {
+      Selector_List_Obj selector1 = ARGSELS("$selector1");
+      Selector_List_Obj selector2 = ARGSELS("$selector2");
+
+      Selector_List_Obj result = selector1->unify_with(selector2);
+      Listize listize;
+      return Cast<Value>(result->perform(&listize));
+    }
+
+    Signature simple_selectors_sig = "simple-selectors($selector)";
+    BUILT_IN(simple_selectors)
+    {
+      Compound_Selector_Obj sel = ARGSEL("$selector");
+
+      List* l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
+
+      for (size_t i = 0, L = sel->length(); i < L; ++i) {
+        Simple_Selector_Obj ss = (*sel)[i];
+        std::string ss_string = ss->to_string() ;
+
+        l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
+      }
+
+      return l;
+    }
+
+    Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
+    BUILT_IN(selector_extend)
+    {
+      Selector_List_Obj  selector = ARGSELS("$selector");
+      Selector_List_Obj  extendee = ARGSELS("$extendee");
+      Selector_List_Obj  extender = ARGSELS("$extender");
+
+      Subset_Map subset_map;
+      extender->populate_extends(extendee, subset_map);
+      Extend extend(subset_map);
+
+      Selector_List_Obj result = extend.extendSelectorList(selector, false);
+
+      Listize listize;
+      return Cast<Value>(result->perform(&listize));
+    }
+
+    Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
+    BUILT_IN(selector_replace)
+    {
+      Selector_List_Obj selector = ARGSELS("$selector");
+      Selector_List_Obj original = ARGSELS("$original");
+      Selector_List_Obj replacement = ARGSELS("$replacement");
+      Subset_Map subset_map;
+      replacement->populate_extends(original, subset_map);
+      Extend extend(subset_map);
+
+      Selector_List_Obj result = extend.extendSelectorList(selector, true);
+
+      Listize listize;
+      return Cast<Value>(result->perform(&listize));
+    }
+
+    Signature selector_parse_sig = "selector-parse($selector)";
+    BUILT_IN(selector_parse)
+    {
+      Selector_List_Obj sel = ARGSELS("$selector");
+
+      Listize listize;
+      return Cast<Value>(sel->perform(&listize));
+    }
+
+    Signature is_superselector_sig = "is-superselector($super, $sub)";
+    BUILT_IN(is_superselector)
+    {
+      Selector_List_Obj  sel_sup = ARGSELS("$super");
+      Selector_List_Obj  sel_sub = ARGSELS("$sub");
+      bool result = sel_sup->is_superselector_of(sel_sub);
+      return SASS_MEMORY_NEW(Boolean, pstate, result);
+    }
+
+  }
+
+}

data/ext/libsass/src/fn_selectors.hpp

@@ -0,0 +1,35 @@
+#ifndef SASS_FN_SELECTORS_H
+#define SASS_FN_SELECTORS_H
+
+#include "fn_utils.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    #define ARGSEL(argname) get_arg_sel(argname, env, sig, pstate, traces, ctx)
+    #define ARGSELS(argname) get_arg_sels(argname, env, sig, pstate, traces, ctx)
+
+    BUILT_IN(selector_nest);
+    BUILT_IN(selector_append);
+    BUILT_IN(selector_extend);
+    BUILT_IN(selector_replace);
+    BUILT_IN(selector_unify);
+    BUILT_IN(is_superselector);
+    BUILT_IN(simple_selectors);
+    BUILT_IN(selector_parse);
+
+    extern Signature selector_nest_sig;
+    extern Signature selector_append_sig;
+    extern Signature selector_extend_sig;
+    extern Signature selector_replace_sig;
+    extern Signature selector_unify_sig;
+    extern Signature is_superselector_sig;
+    extern Signature simple_selectors_sig;
+    extern Signature selector_parse_sig;
+
+  }
+
+}
+
+#endif

data/ext/libsass/src/fn_strings.cpp

@@ -0,0 +1,254 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
+#include <cctype>
+#include "utf8.h"
+#include "ast.hpp"
+#include "fn_utils.hpp"
+#include "fn_strings.hpp"
+
+namespace Sass {
+
+  namespace Functions {
+
+    void handle_utf8_error (const ParserState& pstate, Backtraces traces)
+    {
+      try {
+       throw;
+      }
+      catch (utf8::invalid_code_point&) {
+        std::string msg("utf8::invalid_code_point");
+        error(msg, pstate, traces);
+      }
+      catch (utf8::not_enough_room&) {
+        std::string msg("utf8::not_enough_room");
+        error(msg, pstate, traces);
+      }
+      catch (utf8::invalid_utf8&) {
+        std::string msg("utf8::invalid_utf8");
+        error(msg, pstate, traces);
+      }
+      catch (...) { throw; }
+    }
+
+    ///////////////////
+    // STRING FUNCTIONS
+    ///////////////////
+
+    Signature unquote_sig = "unquote($string)";
+    BUILT_IN(sass_unquote)
+    {
+      AST_Node_Obj arg = env["$string"];
+      if (String_Quoted* string_quoted = Cast<String_Quoted>(arg)) {
+        String_Constant* result = SASS_MEMORY_NEW(String_Constant, pstate, string_quoted->value());
+        // remember if the string was quoted (color tokens)
+        result->is_delayed(true); // delay colors
+        return result;
+      }
+      else if (String_Constant* str = Cast<String_Constant>(arg)) {
+        return str;
+      }
+      else if (Value* ex = Cast<Value>(arg)) {
+        Sass_Output_Style oldstyle = ctx.c_options.output_style;
+        ctx.c_options.output_style = SASS_STYLE_NESTED;
+        std::string val(arg->to_string(ctx.c_options));
+        val = Cast<Null>(arg) ? "null" : val;
+        ctx.c_options.output_style = oldstyle;
+
+        deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
+        return ex;
+      }
+      throw std::runtime_error("Invalid Data Type for unquote");
+    }
+
+    Signature quote_sig = "quote($string)";
+    BUILT_IN(sass_quote)
+    {
+      const String_Constant* s = ARG("$string", String_Constant);
+      String_Quoted *result = SASS_MEMORY_NEW(
+          String_Quoted, pstate, s->value(),
+          /*q=*/'\0', /*keep_utf8_escapes=*/false, /*skip_unquoting=*/true);
+      result->quote_mark('*');
+      return result;
+    }
+
+    Signature str_length_sig = "str-length($string)";
+    BUILT_IN(str_length)
+    {
+      size_t len = std::string::npos;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        len = UTF_8::code_point_count(s->value(), 0, s->value().size());
+
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      // return something even if we had an error (-1)
+      return SASS_MEMORY_NEW(Number, pstate, (double)len);
+    }
+
+    Signature str_insert_sig = "str-insert($string, $insert, $index)";
+    BUILT_IN(str_insert)
+    {
+      std::string str;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        str = s->value();
+        String_Constant* i = ARG("$insert", String_Constant);
+        std::string ins = i->value();
+        double index = ARGVAL("$index");
+        size_t len = UTF_8::code_point_count(str, 0, str.size());
+
+        if (index > 0 && index <= len) {
+          // positive and within string length
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index) - 1), ins);
+        }
+        else if (index > len) {
+          // positive and past string length
+          str += ins;
+        }
+        else if (index == 0) {
+          str = ins + str;
+        }
+        else if (std::abs(index) <= len) {
+          // negative and within string length
+          index += len + 1;
+          str.insert(UTF_8::offset_at_position(str, static_cast<size_t>(index)), ins);
+        }
+        else {
+          // negative and past string length
+          str = ins + str;
+        }
+
+        if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+          if (ss->quote_mark()) str = quote(str);
+        }
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+    }
+
+    Signature str_index_sig = "str-index($string, $substring)";
+    BUILT_IN(str_index)
+    {
+      size_t index = std::string::npos;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        String_Constant* t = ARG("$substring", String_Constant);
+        std::string str = s->value();
+        std::string substr = t->value();
+
+        size_t c_index = str.find(substr);
+        if(c_index == std::string::npos) {
+          return SASS_MEMORY_NEW(Null, pstate);
+        }
+        index = UTF_8::code_point_count(str, 0, c_index) + 1;
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      // return something even if we had an error (-1)
+      return SASS_MEMORY_NEW(Number, pstate, (double)index);
+    }
+
+    Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
+    BUILT_IN(str_slice)
+    {
+      std::string newstr;
+      try {
+        String_Constant* s = ARG("$string", String_Constant);
+        double start_at = ARGVAL("$start-at");
+        double end_at = ARGVAL("$end-at");
+        String_Quoted* ss = Cast<String_Quoted>(s);
+
+        std::string str(s->value());
+
+        size_t size = utf8::distance(str.begin(), str.end());
+
+        if (!Cast<Number>(env["$end-at"])) {
+          end_at = -1;
+        }
+
+        if (end_at == 0 || (end_at + size) < 0) {
+          if (ss && ss->quote_mark()) newstr = quote("");
+          return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
+        }
+
+        if (end_at < 0) {
+          end_at += size + 1;
+          if (end_at == 0) end_at = 1;
+        }
+        if (end_at > size) { end_at = (double)size; }
+        if (start_at < 0) {
+          start_at += size + 1;
+          if (start_at < 0)  start_at = 0;
+        }
+        else if (start_at == 0) { ++ start_at; }
+
+        if (start_at <= end_at)
+        {
+          std::string::iterator start = str.begin();
+          utf8::advance(start, start_at - 1, str.end());
+          std::string::iterator end = start;
+          utf8::advance(end, end_at - start_at + 1, str.end());
+          newstr = std::string(start, end);
+        }
+        if (ss) {
+          if(ss->quote_mark()) newstr = quote(newstr);
+        }
+      }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, traces); }
+      return SASS_MEMORY_NEW(String_Quoted, pstate, newstr);
+    }
+
+    Signature to_upper_case_sig = "to-upper-case($string)";
+    BUILT_IN(to_upper_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      std::string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        if (Sass::Util::isAscii(str[i])) {
+          str[i] = std::toupper(str[i]);
+        }
+      }
+
+      if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+        String_Quoted* cpy = SASS_MEMORY_COPY(ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+      }
+    }
+
+    Signature to_lower_case_sig = "to-lower-case($string)";
+    BUILT_IN(to_lower_case)
+    {
+      String_Constant* s = ARG("$string", String_Constant);
+      std::string str = s->value();
+
+      for (size_t i = 0, L = str.length(); i < L; ++i) {
+        if (Sass::Util::isAscii(str[i])) {
+          str[i] = std::tolower(str[i]);
+        }
+      }
+
+      if (String_Quoted* ss = Cast<String_Quoted>(s)) {
+        String_Quoted* cpy = SASS_MEMORY_COPY(ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, str);
+      }
+    }
+
+  }
+
+}