sassc 1.8.4 → 1.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fe1d16ee2088d1a7579e272a1a7e06ec45fcfc4
-  data.tar.gz: fdf4b18309732cf9657becf31f4cf42170cce51c
+  metadata.gz: ab6f4c497bb370c122244297018added959a8af8
+  data.tar.gz: ad910a4be141fd033b143c1723f7a8dfef523243
 SHA512:
-  metadata.gz: 9182f4bbf92967e5dae1c870427d372d1bb672f7fab914a4b412d032ab2391456a2989dc5313e71f9e50d476e905d16ee72de22038136ead8674c58a074a38cb
-  data.tar.gz: 80fe5528ca2af133a4075ee84b9b3aafd0f1c8eb11aa73ac827eaf96cdedbd349ad933f5f0a990fffeb43ce96b866de0b2bed50f3b5c809dfe5f22f9dde6096f
+  metadata.gz: 1cd8b55db12f25fca765171af3e7ae3f11702e39a0df778009088dc254777ee90bd138467ef4efcbc865e507c096ce165f3dcd8abae3bfe925eec9e084eaa83d
+  data.tar.gz: 45205737303fbaca70c190457d30d234eec1c814bd279810bac275a7360c09a59f8f1a0552c6321b658023d986f5e6d4fb7887d8682bcbc45fbdbf1ea685e310

data/README.md

@@ -25,6 +25,8 @@ and [awesome contributors](https://github.com/bolandrm/sassc-ruby/graphs/contrib
 
 ## Changelog
 
+- **1.8.5**
+  - Update to Libsass 3.3.4
 - **1.8.4**
   - Update to Libsass 3.3.3
 - **1.8.3**

data/ext/libsass/LICENSE

@@ -1,5 +1,5 @@
 
-Copyright (C) 2012-2016 by Hampton Catlin
+Copyright (C) 2012-2016 by the Sass Open Source Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/ext/libsass/Readme.md

@@ -3,7 +3,7 @@ LibSass
 
 by Aaron Leung ([@akhleung]), Hampton Catlin ([@hcatlin]), Marcel Greter ([@mgreter]) and Michael Mifsud ([@xzyfer])
 
-[![Linux CI](https://travis-ci.org/sass/libsass.png?branch=master)](https://travis-ci.org/sass/libsass)
+[![Linux CI](https://travis-ci.org/sass/libsass.svg?branch=master)](https://travis-ci.org/sass/libsass)
 [![Windows CI](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/sass/libsass/branch/master)
 [![Bountysource](https://www.bountysource.com/badge/tracker?tracker_id=283068)](https://www.bountysource.com/trackers/283068-libsass?utm_source=283068&utm_medium=shield&utm_campaign=TRACKER_BADGE)
 [![Coverage Status](https://img.shields.io/coveralls/sass/libsass.svg)](https://coveralls.io/r/sass/libsass?branch=feature%2Ftest-travis-ci-3)
@@ -13,7 +13,7 @@ https://github.com/sass/libsass
 
 LibSass is just a library, but if you want to RUN LibSass,
 then go to https://github.com/sass/sassc or
-https://github.com/sass/ruby-libsass or
+https://github.com/sass/sassc-ruby or
 [find your local implementer](docs/implementations.md).
 
 LibSass requires GCC 4.6+ or Clang/LLVM. If your OS is older, this version may not compile.
@@ -68,20 +68,16 @@ Sass is a CSS pre-processor language to add on exciting, new,
 awesome features to CSS. Sass was the first language of its kind
 and by far the most mature and up to date codebase.
 
-Sass was originally created by the co-creator of this library,
-Hampton Catlin ([@hcatlin]). The extension and continuing evolution
-of the language has all been the result of years of work by Natalie
-Weizenbaum ([@nex3]) and Chris Eppstein ([@chriseppstein]).
+Sass was originally concieved of by the co-creator of this library,
+Hampton Catlin ([@hcatlin]). Most of the language has been the result of years
+of work by Natalie Weizenbaum ([@nex3]) and Chris Eppstein ([@chriseppstein]).
 
 For more information about Sass itself, please visit http://sass-lang.com
 
-Contribution Agreement
-----------------------
+Initial development of libsass by Aaron Leung and Hampton Catlin was supported by [Moovweb](http://www.moovweb.com).
 
-Any contribution to the project are seen as copyright assigned to Hampton Catlin, a
-human on the planet earth. Your contribution warrants that you have the right to
-assign copyright on your work. The intention here is to ensure that the project
-remains totally free (liberal, like).
+Licensing
+---------
 
 Our MIT license is designed to be as simple, and liberal as possible.
 
@@ -94,4 +90,3 @@ Our MIT license is designed to be as simple, and liberal as possible.
 
 sass2scss was originally written by [Marcel Greter](@mgreter)
 and he happily agreed to have it merged into the project.
-

data/ext/libsass/appveyor.yml

@@ -1,4 +1,4 @@
-os: Visual Studio 2015
+os: Visual Studio 2013
 
 environment:
   CTEST_OUTPUT_ON_FAILURE: 1

data/ext/libsass/src/ast.cpp

@@ -949,6 +949,7 @@ namespace Sass {
 
   Selector_List* Selector_List::parentize(Selector_List* ps, Context& ctx)
   {
+    if (!this->has_parent_ref()) return this;
     Selector_List* ss = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
     for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {
       Selector_List* list = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
@@ -1085,18 +1086,16 @@ namespace Sass {
   Complex_Selector* Complex_Selector::first()
   {
     // declare variables used in loop
-    Complex_Selector* cur = this->tail_;
-    const Compound_Selector* head = head_;
+    Complex_Selector* cur = this;
+    const Compound_Selector* head;
     // processing loop
     while (cur)
     {
       // get the head
       head = cur->head_;
-      // check for single parent ref
-      if (head && head->length() == 1)
-      {
-        // abort (and return) if it is not a parent selector
-        if (!dynamic_cast<Parent_Selector*>((*head)[0])) break;
+      // abort (and return) if it is not a parent selector
+      if (!head || head->length() != 1 || !dynamic_cast<Parent_Selector*>((*head)[0])) {
+        break;
       }
       // advance to next
       cur = cur->tail_;
@@ -1897,6 +1896,10 @@ namespace Sass {
     return false;
   }
 
+  bool String_Constant::is_invisible() const {
+    return value_.empty() && quote_mark_ == 0;
+  }
+
   bool String_Constant::operator== (const Expression& rhs) const
   {
     if (const String_Quoted* qstr = dynamic_cast<const String_Quoted*>(&rhs)) {
@@ -2030,14 +2033,6 @@ namespace Sass {
     return to_string({ NESTED, 5 });
   }
 
-  // helper function for serializing colors
-  template <size_t range>
-  static double cap_channel(double c) {
-    if      (c > range) return range;
-    else if (c < 0)     return 0;
-    else                return c;
-  }
-
   std::string String_Quoted::inspect() const
   {
     return quote(value_, '*');
@@ -2064,4 +2059,3 @@ namespace Sass {
   }
 
 }
-

data/ext/libsass/src/ast.hpp

@@ -1514,6 +1514,7 @@ namespace Sass {
     { }
     std::string type() { return "string"; }
     static std::string type_name() { return "string"; }
+    virtual bool is_invisible() const;
 
     virtual size_t hash()
     {

data/ext/libsass/src/context.cpp

@@ -351,8 +351,9 @@ namespace Sass {
 
     // process the resolved entry
     else if (resolved.size() == 1) {
+      bool use_cache = c_importers.size() == 0;
       // use cache for the resource loading
-      if (sheets.count(resolved[0].abs_path)) return resolved[0];
+      if (use_cache && sheets.count(resolved[0].abs_path)) return resolved[0];
       // try to read the content of the resolved file entry
       // the memory buffer returned must be freed by us!
       if (char* contents = read_file(resolved[0].abs_path)) {
@@ -436,7 +437,7 @@ namespace Sass {
           // query data from the current include
           Sass_Import_Entry include = *it_includes;
           char* source = sass_import_take_source(include);
-          char* srcmap = sass_import_take_source(include);
+          char* srcmap = sass_import_take_srcmap(include);
           size_t line = sass_import_get_error_line(include);
           size_t column = sass_import_get_error_column(include);
           const char *abs_path = sass_import_get_abs_path(include);

data/ext/libsass/src/debugger.hpp

@@ -357,6 +357,7 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
     Import_Stub* block = dynamic_cast<Import_Stub*>(node);
     std::cerr << ind << "Import_Stub " << block;
     std::cerr << " (" << pstate_source_position(node) << ")";
+    std::cerr << " [" << block->imp_path() << "] ";
     std::cerr << " " << block->tabs() << std::endl;
   } else if (dynamic_cast<Import*>(node)) {
     Import* block = dynamic_cast<Import*>(node);

data/ext/libsass/src/eval.cpp

@@ -504,22 +504,22 @@ namespace Sass {
     }
 
     // only the last item will be used to eval the binary expression
-    if (String_Schema* s_1 = dynamic_cast<String_Schema*>(b->left())) {
-      if (!s_1->is_right_interpolant()) {
-        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, s_1->pstate());
+    if (String_Schema* s_l = dynamic_cast<String_Schema*>(b->left())) {
+      if (!s_l->has_interpolant() && (!s_l->is_right_interpolant())) {
+        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, s_l->pstate());
         Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
-                                                    b->op(), s_1->last(), b->right());
+                                                    b->op(), s_l->last(), b->right());
         bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed());
         // bin_ex->is_interpolant(b->left()->is_interpolant());
-        for (size_t i = 0; i < s_1->length() - 1; ++i) {
-          *ret_schema << s_1->at(i)->perform(this);
+        for (size_t i = 0; i < s_l->length() - 1; ++i) {
+          *ret_schema << s_l->at(i)->perform(this);
         }
         *ret_schema << bin_ex->perform(this);
         return ret_schema->perform(this);
       }
     }
     if (String_Schema* s_r = dynamic_cast<String_Schema*>(b->right())) {
-      if (!s_r->is_left_interpolant() || op_type == Sass_OP::DIV) {
+      if (!s_r->has_interpolant() && (!s_r->is_left_interpolant() || op_type == Sass_OP::DIV)) {
         ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, s_r->pstate());
         Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
                                                     b->op(), b->left(), s_r->first());
@@ -691,7 +691,7 @@ namespace Sass {
         }
       }
 
-    if (force_delay) {
+      if (force_delay) {
         std::string str("");
         str += v_l->to_string(ctx.c_options);
         if (b->op().ws_before) str += " ";
@@ -1125,11 +1125,12 @@ namespace Sass {
     if (List* l = dynamic_cast<List*>(ex)) {
       List* ll = SASS_MEMORY_NEW(ctx.mem, List, l->pstate(), 0, l->separator());
       // this fixes an issue with bourbon sample, not really sure why
-      if (l->size() && dynamic_cast<Null*>((*l)[0])) { res += " "; }
+      // if (l->size() && dynamic_cast<Null*>((*l)[0])) { res += ""; }
       for(auto item : *l) {
         item->is_interpolant(l->is_interpolant());
         std::string rl(""); interpolation(ctx, rl, item, into_quotes, l->is_interpolant());
-        if (rl != "") *ll << SASS_MEMORY_NEW(ctx.mem, String_Quoted, item->pstate(), rl);
+        bool is_null = dynamic_cast<Null*>(item) != 0; // rl != ""
+        if (!is_null) *ll << SASS_MEMORY_NEW(ctx.mem, String_Quoted, item->pstate(), rl);
       }
       res += (ll->to_string(ctx.c_options));
       ll->is_interpolant(l->is_interpolant());
@@ -1170,15 +1171,22 @@ namespace Sass {
       }
       }
     }
+    bool was_quoted = false;
+    bool was_interpolant = false;
     std::string res("");
     for (size_t i = 0; i < L; ++i) {
+      bool is_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
       (*s)[i]->perform(this);
+      if (was_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
+      else if (i > 0 && is_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
       Expression* ex = (*s)[i]->is_delayed() ? (*s)[i] : (*s)[i]->perform(this);
       interpolation(ctx, res, ex, into_quotes, ex->is_interpolant());
+      was_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
+      was_interpolant = (*s)[i]->is_interpolant();
 
     }
     if (!s->is_interpolant()) {
-      if (res == "") return SASS_MEMORY_NEW(ctx.mem, Null, s->pstate());
+      if (s->length() > 1 && res == "") return SASS_MEMORY_NEW(ctx.mem, Null, s->pstate());
       return SASS_MEMORY_NEW(ctx.mem, String_Constant, s->pstate(), res);
     }
     String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, s->pstate(), res);

data/ext/libsass/src/expand.cpp

@@ -117,6 +117,17 @@ namespace Sass {
     Selector_List* sel = dynamic_cast<Selector_List*>(ex);
     if (sel == 0) throw std::runtime_error("Expanded null selector");
 
+    if (sel->length() == 0 || sel->has_parent_ref()) {
+      bool has_parent_selector = false;
+      for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
+        Selector_List* ll = selector_stack.at(i);
+        has_parent_selector = ll != 0 && ll->length() > 0;
+      }
+      if (!has_parent_selector) {
+        error("Base-level rules cannot contain the parent-selector-referencing character '&'.", sel->pstate(), backtrace());
+      }
+    }
+
     selector_stack.push_back(sel);
     Env* env = 0;
     if (block_stack.back()->is_root()) {

data/ext/libsass/src/functions.cpp

@@ -1690,7 +1690,6 @@ namespace Sass {
         Sass_Output_Style old_style;
         old_style = ctx.c_options.output_style;
         ctx.c_options.output_style = TO_SASS;
-        Sass_Output_Options out(ctx.c_options);
         Emitter emitter(ctx.c_options);
         Inspect i(emitter);
         i.in_declaration = false;

data/ext/libsass/src/inspect.cpp

@@ -406,7 +406,10 @@ namespace Sass {
       Expression* list_item = (*list)[i];
       if (output_style() != TO_SASS) {
         if (list_item->is_invisible()) {
-          continue;
+          // this fixes an issue with "" in a list
+          if (!dynamic_cast<String_Constant*>(list_item)) {
+            continue;
+          }
         }
       }
       if (items_output) {

data/ext/libsass/src/json.cpp

@@ -544,42 +544,50 @@ JsonNode *json_mkobject(void)
 
 static void append_node(JsonNode *parent, JsonNode *child)
 {
-  child->parent = parent;
-  child->prev = parent->children.tail;
-  child->next = NULL;
-
-  if (parent->children.tail != NULL)
-    parent->children.tail->next = child;
-  else
-    parent->children.head = child;
-  parent->children.tail = child;
+  if (child != NULL && parent != NULL) {
+      child->parent = parent;
+      child->prev = parent->children.tail;
+      child->next = NULL;
+      
+      if (parent->children.tail != NULL)
+          parent->children.tail->next = child;
+      else
+          parent->children.head = child;
+      parent->children.tail = child;
+  }
 }
 
 static void prepend_node(JsonNode *parent, JsonNode *child)
 {
-  child->parent = parent;
-  child->prev = NULL;
-  child->next = parent->children.head;
-
-  if (parent->children.head != NULL)
-    parent->children.head->prev = child;
-  else
-    parent->children.tail = child;
-  parent->children.head = child;
+  if (child != NULL && parent != NULL) {
+      child->parent = parent;
+      child->prev = NULL;
+      child->next = parent->children.head;
+      
+      if (parent->children.head != NULL)
+          parent->children.head->prev = child;
+      else
+          parent->children.tail = child;
+      parent->children.head = child;
+  }
 }
 
 static void append_member(JsonNode *object, char *key, JsonNode *value)
 {
-  value->key = key;
-  append_node(object, value);
+  if (value != NULL && object != NULL) {
+      value->key = key;
+      append_node(object, value);
+  }
 }
 
 void json_append_element(JsonNode *array, JsonNode *element)
 {
-  assert(array->tag == JSON_ARRAY);
-  assert(element->parent == NULL);
-
-  append_node(array, element);
+  if (array != NULL && element !=NULL) {
+      assert(array->tag == JSON_ARRAY);
+      assert(element->parent == NULL);
+      
+      append_node(array, element);
+  }
 }
 
 void json_prepend_element(JsonNode *array, JsonNode *element)
@@ -592,40 +600,47 @@ void json_prepend_element(JsonNode *array, JsonNode *element)
 
 void json_append_member(JsonNode *object, const char *key, JsonNode *value)
 {
-  assert(object->tag == JSON_OBJECT);
-  assert(value->parent == NULL);
-
-  append_member(object, json_strdup(key), value);
+  if (object != NULL && key != NULL && value != NULL) {
+      assert(object->tag == JSON_OBJECT);
+      assert(value->parent == NULL);
+      
+      append_member(object, json_strdup(key), value);
+  }
 }
 
 void json_prepend_member(JsonNode *object, const char *key, JsonNode *value)
 {
-  assert(object->tag == JSON_OBJECT);
-  assert(value->parent == NULL);
-
-  value->key = json_strdup(key);
-  prepend_node(object, value);
+  if (object != NULL && key != NULL && value != NULL) {
+      assert(object->tag == JSON_OBJECT);
+      assert(value->parent == NULL);
+      
+      value->key = json_strdup(key);
+      prepend_node(object, value);
+  }
 }
 
 void json_remove_from_parent(JsonNode *node)
 {
-  JsonNode *parent = node->parent;
-
-  if (parent != NULL) {
-    if (node->prev != NULL)
-      node->prev->next = node->next;
-    else
-      parent->children.head = node->next;
-    if (node->next != NULL)
-      node->next->prev = node->prev;
-    else
-      parent->children.tail = node->prev;
-
-    free(node->key);
-
-    node->parent = NULL;
-    node->prev = node->next = NULL;
-    node->key = NULL;
+  if (node != NULL) {
+      JsonNode *parent = node->parent;
+      
+      if (parent != NULL) {
+          if (node->prev != NULL)
+              node->prev->next = node->next;
+          else
+              parent->children.head = node->next;
+		  
+          if (node->next != NULL)
+              node->next->prev = node->prev;
+          else
+              parent->children.tail = node->prev;
+          
+          free(node->key);
+          
+          node->parent = NULL;
+          node->prev = node->next = NULL;
+          node->key = NULL;
+      }
   }
 }
 

data/ext/libsass/src/lexer.cpp

@@ -137,7 +137,7 @@ namespace Sass {
     const char* any_char(const char* src) { return *src ? src + 1 : src; }
 
     // Match word boundary (zero-width lookahead).
-    const char* word_boundary(const char* src) { return is_character(*src) ? 0 : src; }
+    const char* word_boundary(const char* src) { return is_character(*src) || *src == '#' ? 0 : src; }
 
     // Match linefeed /(?:\n|\r\n?)/
     const char* re_linebreak(const char* src)

data/ext/libsass/src/output.cpp

@@ -67,7 +67,8 @@ namespace Sass {
     // search for unicode char
     for(const char& chr : wbuf.buffer) {
       // skip all ascii chars
-      if (chr >= 0) continue;
+      // static cast to unsigned to handle `char` being signed / unsigned
+      if (static_cast<unsigned>(chr) < 128) continue;
       // declare the charset
       if (output_style() != COMPRESSED)
         charset = "@charset \"UTF-8\";"

data/ext/libsass/src/parser.cpp

@@ -200,7 +200,7 @@ namespace Sass {
 
     // abort if we are in function context and have nothing parsed yet
     else if (stack.back() == Scope::Function) {
-      error("Functions can only contain variable declarations and control directives", pstate);
+      error("Functions can only contain variable declarations and control directives.", pstate);
     }
 
     // parse imports to process later
@@ -221,8 +221,7 @@ namespace Sass {
     }
 
     else if (lex < kwd_extend >(true)) {
-      Scope parent = stack.empty() ? Scope::Rules : stack.back();
-      if (parent == Scope::Root) {
+      if (block->is_root()) {
         error("Extend directives may only be used within rules.", pstate);
       }
 
@@ -290,12 +289,7 @@ namespace Sass {
     do {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
-        if (!ctx.call_importers(unquote(std::string(lexed)), path, pstate, imp))
-        {
-          // push single file import
-          // import_single_file(imp, lexed);
-          to_import.push_back(std::pair<std::string,Function_Call*>(std::string(lexed), 0));
-        }
+        to_import.push_back(std::pair<std::string,Function_Call*>(std::string(lexed), 0));
       }
       else if (lex< uri_prefix >()) {
         Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, pstate);
@@ -333,7 +327,7 @@ namespace Sass {
     for(auto location : to_import) {
       if (location.second) {
         imp->urls().push_back(location.second);
-      } else {
+      } else if (!ctx.call_importers(unquote(location.first), path, pstate, imp)) {
         ctx.import_url(imp, location.first, path);
       }
     }
@@ -345,7 +339,12 @@ namespace Sass {
   {
     Scope parent = stack.empty() ? Scope::Rules : stack.back();
     if (parent != Scope::Root && parent != Scope::Rules && parent != Scope::Function) {
-      error("Functions may not be defined within control directives or other mixins.", pstate);
+      if (which_type == Definition::FUNCTION) {
+        error("Functions may not be defined within control directives or other mixins.", pstate);
+      } else {
+        error("Mixins may not be defined within control directives or other mixins.", pstate);
+      }
+
     }
     std::string which_str(lexed);
     if (!lex< identifier >()) error("invalid name in " + which_str + " definition", pstate);
@@ -615,7 +614,7 @@ namespace Sass {
       while (peek_css< exactly<','> >())
       {
         lex< css_comments >(false);
-        // consume everything up and including the comma speparator
+        // consume everything up and including the comma separator
         reloop = lex< exactly<','> >() != 0;
         // remember line break (also between some commas)
         had_linefeed = had_linefeed || peek_newline();
@@ -719,7 +718,7 @@ namespace Sass {
   // EO parse_complex_selector
 
   // parse one compound selector, which is basically
-  // a list of simple selectors (directly adjancent)
+  // a list of simple selectors (directly adjacent)
   // lex them exactly (without skipping white-space)
   Compound_Selector* Parser::parse_compound_selector()
   {
@@ -747,7 +746,7 @@ namespace Sass {
         seq->has_parent_reference(true);
         (*seq) << SASS_MEMORY_NEW(ctx.mem, Parent_Selector, pstate);
         // parent selector only allowed at start
-        // upcoming sass may allow also trailing
+        // upcoming Sass may allow also trailing
         if (seq->length() > 1) {
           ParserState state(pstate);
           Simple_Selector* cur = (*seq)[seq->length()-1];
@@ -834,7 +833,7 @@ namespace Sass {
   }
 
   // a pseudo selector often starts with one or two colons
-  // it can contain more selectors inside parantheses
+  // it can contain more selectors inside parentheses
   Simple_Selector* Parser::parse_pseudo_selector() {
     if (lex< sequence<
           optional < pseudo_prefix >,
@@ -1213,9 +1212,9 @@ namespace Sass {
       : lex<kwd_lte>() ? Sass_OP::LTE
       : lex<kwd_gt>()  ? Sass_OP::GT
       : lex<kwd_lt>()  ? Sass_OP::LT
-      // we checked the possibilites on top of fn
+      // we checked the possibilities on top of fn
       :                  Sass_OP::EQ;
-      // is directly adjancent to expression?
+      // is directly adjacent to expression?
       bool right_ws = peek < css_comments >() != NULL;
       operators.push_back({ op, left_ws, right_ws });
       operands.push_back(parse_expression());
@@ -1238,7 +1237,6 @@ namespace Sass {
     // NOTE: dashes do NOT count as subtract operation
     Expression* lhs = parse_operators();
     // if it's a singleton, return it (don't wrap it)
-    // if it's a singleton, return it (don't wrap it)
     if (!(peek_css< exactly<'+'> >(position) ||
           // condition is a bit misterious, but some combinations should not be counted as operations
           (peek< no_spaces >(position) && peek< sequence< negate< unsigned_number >, exactly<'-'>, negate< space > > >(position)) ||
@@ -1308,7 +1306,6 @@ namespace Sass {
       if (!lex_css< exactly<')'> >()) error("unclosed parenthesis", pstate);
       // expression can be evaluated
       // make sure wrapped lists and division expressions are non-delayed within parentheses
-      // make sure wrapped lists and division expressions are non-delayed within parentheses
       if (value->concrete_type() == Expression::LIST) {
         // List* l = static_cast<List*>(value);
         // if (!l->empty()) (*l)[0]->is_delayed(false);
@@ -1416,7 +1413,7 @@ namespace Sass {
     if (lex< percentage >())
     { return SASS_MEMORY_NEW(ctx.mem, Textual, pstate, Textual::PERCENTAGE, lexed); }
 
-    // match hex number first because 0x000 looks like a number followed by an indentifier
+    // match hex number first because 0x000 looks like a number followed by an identifier
     if (lex< sequence < alternatives< hex, hex0 >, negate < exactly<'-'> > > >())
     { return SASS_MEMORY_NEW(ctx.mem, Textual, pstate, Textual::HEX, lexed); }
 
@@ -1598,6 +1595,8 @@ namespace Sass {
     }
 
     const char* e = 0;
+    const char* ee = end;
+    end = stop;
     size_t num_items = 0;
     bool need_space = false;
     while (position < stop) {
@@ -1607,7 +1606,7 @@ namespace Sass {
       }
       if (need_space) {
         need_space = false;
-        (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, " ");
+        // (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, " ");
       }
       if ((e = peek< re_functional >()) && e < stop) {
         (*schema) << parse_function_call();
@@ -1630,23 +1629,26 @@ namespace Sass {
         lex < exactly < rbrace > >();
       }
       // lex some string constants or other valid token
-      // Note: [-+] chars are left over from ie. `#{3}+3`
+      // Note: [-+] chars are left over from i.e. `#{3}+3`
       else if (lex< alternatives < exactly<'%'>, exactly < '-' >, exactly < '+' > > >()) {
         (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
       }
-      else if (lex< sequence < identifier > >()) {
-        (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+      // lex a quoted string
+      else if (lex< quoted_string >()) {
+        // need_space = true;
+        // if (schema->length()) (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, " ");
+        // else need_space = true;
+        (*schema) << parse_string();
         if ((*position == '"' || *position == '\'') || peek < alternatives < alpha > >()) {
-          need_space = true;
+          // need_space = true;
         }
+        if (peek < exactly < '-' > >()) break;
       }
-      // lex a quoted string
-      else if (lex< quoted_string >()) {
-        (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, lexed, '"');
+      else if (lex< sequence < identifier > >()) {
+        (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
         if ((*position == '"' || *position == '\'') || peek < alternatives < alpha > >()) {
-          need_space = true;
+           // need_space = true;
         }
-        if (peek < exactly < '-' > >()) return schema;
       }
       // lex (normalized) variable
       else if (lex< variable >()) {
@@ -1677,10 +1679,15 @@ namespace Sass {
         (*schema) << parse_factor();
       }
       else {
-        return schema;
+        break;
       }
       ++num_items;
     }
+    if (position != stop) {
+      (*schema) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, std::string(position, stop));
+      position = stop;
+    }
+    end = ee;
     return schema;
   }
 
@@ -1773,6 +1780,11 @@ namespace Sass {
       suffix = std::string(lexed);
     }
 
+    std::string uri("");
+    if (url_string) {
+      uri = url_string->to_string({ NESTED, 5 });
+    }
+
     if (String_Schema* schema = dynamic_cast<String_Schema*>(url_string)) {
       String_Schema* res = SASS_MEMORY_NEW(ctx.mem, String_Schema, pstate);
       (*res) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, prefix);
@@ -1780,7 +1792,7 @@ namespace Sass {
       (*res) << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, suffix);
       return res;
     } else {
-      std::string res = prefix + url_string->to_string({ NESTED, 5 }) + suffix;
+      std::string res = prefix + uri + suffix;
       return SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, res);
     }
   }
@@ -1894,7 +1906,7 @@ namespace Sass {
     if (!peek< exactly <'$'> >()) {
       css_error("Invalid CSS", " after ", ": expected \"$\", was ");
     }
-    // we expect a simple identfier as the call name
+    // we expect a simple identifier as the call name
     if (!lex< sequence < exactly <'$'>, identifier > >()) {
       lex< exactly <'$'> >(); // move pstate and position up
       css_error("Invalid CSS", " after ", ": expected identifier, was ");
@@ -1905,7 +1917,7 @@ namespace Sass {
   // helper to parse identifier
   Token Parser::lex_identifier()
   {
-    // we expect a simple identfier as the call name
+    // we expect a simple identifier as the call name
     if (!lex< identifier >()) { // ToDo: pstate wrong?
       css_error("Invalid CSS", " after ", ": expected identifier, was ");
     }
@@ -2092,7 +2104,7 @@ namespace Sass {
   }
 
   // TODO: This needs some major work. Although feature conditions
-  // look like declarations their semantics differ siginificantly
+  // look like declarations their semantics differ significantly
   Supports_Condition* Parser::parse_supports_declaration()
   {
     Supports_Condition* cond = 0;
@@ -2132,7 +2144,6 @@ namespace Sass {
     Block* body = 0;
     At_Root_Expression* expr = 0;
     Lookahead lookahead_result;
-    // stack.push_back(Scope::Root);
     LOCAL_FLAG(in_at_root, true);
     if (lex< exactly<'('> >()) {
       expr = parse_at_root_expression();
@@ -2147,7 +2158,6 @@ namespace Sass {
     }
     At_Root_Block* at_root = SASS_MEMORY_NEW(ctx.mem, At_Root_Block, at_source_position, body);
     if (expr) at_root->expression(expr);
-    // stack.pop_back();
     return at_root;
   }
 
@@ -2259,7 +2269,7 @@ namespace Sass {
     if (const char* q =
       peek <
         alternatives <
-          // partial bem selector
+          // partial BEM selector
           sequence <
             ampersand,
             one_plus <
@@ -2300,7 +2310,7 @@ namespace Sass {
                   // single or double colon
                   optional < pseudo_prefix >
                 >,
-                // accept hypens in token
+                // accept hyphens in token
                 one_plus < sequence <
                   // can start with hyphens
                   zero_plus < exactly<'-'> >,
@@ -2389,19 +2399,27 @@ namespace Sass {
         non_greedy <
           alternatives <
             // consume whitespace
-            block_comment, spaces,
+            block_comment, // spaces,
             // main tokens
-            interpolant,
+            sequence <
+              interpolant,
+              optional <
+                quoted_string
+              >
+            >,
             identifier,
             variable,
             // issue #442
             sequence <
               parenthese_scope,
-              interpolant
+              interpolant,
+              optional <
+                quoted_string
+              >
             >
           >,
           sequence <
-            optional_spaces,
+            // optional_spaces,
             alternatives <
               exactly<'{'>,
               exactly<'}'>,
@@ -2424,7 +2442,7 @@ namespace Sass {
       // ToDo: remove
       rv.position = q;
       // check expected opening bracket
-      // only after successfull matching
+      // only after successful matching
       if (peek < exactly<'{'> >(q)) rv.found = q;
       else if (peek < exactly<';'> >(q)) rv.found = q;
       else if (peek < exactly<'}'> >(q)) rv.found = q;

data/ext/libsass/src/parser.hpp

@@ -116,7 +116,10 @@ namespace Sass {
       const char* it_before_token = sneak < mx >(start);
 
       // match the given prelexer
-      return mx(it_before_token);
+      const char* match = mx(it_before_token);
+
+      // check if match is in valid range
+      return match <= end ? match : 0;
 
     }
 
@@ -142,6 +145,9 @@ namespace Sass {
       // now call matcher to get position after token
       const char* it_after_token = mx(it_before_token);
 
+      // check if match is in valid range
+      if (it_after_token > end) return 0;
+
       // maybe we want to update the parser state anyway?
       if (force == false) {
         // assertion that we got a valid match

data/ext/libsass/src/sass_context.cpp

@@ -220,7 +220,10 @@ extern "C" {
       size_t imp_size = 0; while (imp) { imp_size ++; imp = imp->next; }
       // create char* array to hold all paths plus null terminator
       const char** plugin_paths = (const char**) calloc(imp_size + 1, sizeof(char*));
-      if (plugin_paths == 0) throw(std::bad_alloc());
+      if (plugin_paths == 0) {
+          free(include_paths); //free include_paths before throw
+          throw(std::bad_alloc());
+      }
       // reset iterator
       imp = c_ctx->plugin_paths;
       // copy over the paths

data/lib/sassc/version.rb

@@ -1,3 +1,3 @@
 module SassC
-  VERSION = "1.8.4"
+  VERSION = "1.8.5"
 end

data/lib/tasks/libsass.rb

@@ -17,6 +17,15 @@ namespace :libsass do
   end
 
   file "lib/libsass.so" => "Makefile" do
-    sh 'make lib/libsass.so'
+    make_program = ENV['MAKE']
+    make_program ||= case RUBY_PLATFORM
+                     when /mswin/
+                       'nmake'
+                     when /(bsd|solaris)/
+                       'gmake'
+                     else
+                       'make'
+                     end
+    sh "#{make_program} lib/libsass.so"
   end
 end

data/test/native_test.rb

@@ -9,7 +9,7 @@ module SassC
 
     class General < MiniTest::Test
       def test_it_reports_the_libsass_version
-        assert_equal "3.3.3", Native.version
+        assert_equal "3.3.4", Native.version
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sassc
 version: !ruby/object:Gem::Version
-  version: 1.8.4
+  version: 1.8.5
 platform: ruby
 authors:
 - Ryan Boland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-20 00:00:00.000000000 Z
+date: 2016-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake