sassc 1.8.1 → 1.8.2

data/ext/libsass/src/json.cpp

@@ -802,7 +802,7 @@ failure:
 bool parse_string(const char **sp, char **out)
 {
   const char *s = *sp;
-  SB sb = { 0, 0, 0};
+  SB sb = { 0, 0, 0 };
   char throwaway_buffer[4];
     /* enough space for a UTF-8 character */
   char *b;

data/ext/libsass/src/lexer.hpp

@@ -84,14 +84,14 @@ namespace Sass {
     //####################################
 
     // Match a single character literal.
-    // Regex equivalent: /(?:literal)/
+    // Regex equivalent: /(?:x)/
     template <char chr>
     const char* exactly(const char* src) {
       return *src == chr ? src + 1 : 0;
     }
 
-    // Match a string constant.
-    // Regex equivalent: /[axy]/
+    // Match the full string literal.
+    // Regex equivalent: /(?:literal)/
     template <const char* str>
     const char* exactly(const char* src) {
       if (str == 0) return 0;
@@ -102,7 +102,26 @@ namespace Sass {
       while (*pre && *src == *pre) {
         ++src, ++pre;
       }
-      return *pre ? 0 : src;
+      // did the matcher finish?
+      return *pre == 0 ? src : 0;
+    }
+
+
+    // Match the full string literal.
+    // Regex equivalent: /(?:literal)/i
+    // only define lower case alpha chars
+    template <const char* str>
+    const char* insensitive(const char* src) {
+      if (str == 0) return 0;
+      const char* pre = str;
+      if (src == 0) return 0;
+      // there is a small chance that the search string
+      // is longer than the rest of the string to look at
+      while (*pre && (*src == *pre || *src+32 == *pre)) {
+        ++src, ++pre;
+      }
+      // did the matcher finish?
+      return *pre == 0 ? src : 0;
     }
 
     // Match for members of char class.
@@ -225,6 +244,16 @@ namespace Sass {
     // ADVANCED "REGEX" CONSTRUCTORS
     //####################################
 
+    // Match with word boundary rule.
+    // Regex equivalent: /(?:$mx)\b/i
+    template <const char* str>
+    const char* keyword(const char* src) {
+      return sequence <
+               insensitive < str >,
+               word_boundary
+             >(src);
+    }
+
     // Match with word boundary rule.
     // Regex equivalent: /(?:$mx)\b/
     template <const char* str>

data/ext/libsass/src/output.cpp

@@ -74,7 +74,7 @@ namespace Sass {
       // skip all ascii chars
       if (chr >= 0) continue;
       // declare the charset
-      if (output_style() != COMPRESSED)
+      if (output_style() != SASS_STYLE_COMPRESSED)
         charset = "@charset \"UTF-8\";"
                   + ctx->linefeed;
       else charset = "\xEF\xBB\xBF";
@@ -95,7 +95,7 @@ namespace Sass {
     std::string txt = c->text()->perform(&to_string);
     // if (indentation && txt == "/**/") return;
     bool important = c->is_important();
-    if (output_style() != COMPRESSED || important) {
+    if (output_style() != SASS_STYLE_COMPRESSED || important) {
       if (buffer().size() == 0) {
         top_nodes.push_back(c);
       } else {
@@ -131,11 +131,11 @@ namespace Sass {
 
     if (b->has_non_hoistable()) {
       decls = true;
-      if (output_style() == NESTED) indentation += r->tabs();
-      if (ctx && ctx->source_comments) {
+      if (output_style() == SASS_STYLE_NESTED) indentation += r->tabs();
+      if (ctx && ctx->c_options->source_comments) {
         std::stringstream ss;
         append_indentation();
-        ss << "/* line " << r->pstate().line+1 << ", " << r->pstate().path << " */";
+        ss << "/* line " << r->pstate().line + 1 << ", " << r->pstate().path << " */";
         append_string(ss.str());
         append_optional_linefeed();
       }
@@ -171,7 +171,7 @@ namespace Sass {
           stm->perform(this);
         }
       }
-      if (output_style() == NESTED) indentation -= r->tabs();
+      if (output_style() == SASS_STYLE_NESTED) indentation -= r->tabs();
       append_scope_closer(b);
     }
 
@@ -238,7 +238,7 @@ namespace Sass {
       return;
     }
 
-    if (output_style() == NESTED) indentation += f->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation += f->tabs();
     append_indentation();
     append_token("@supports", f);
     append_mandatory_space();
@@ -274,7 +274,7 @@ namespace Sass {
       }
     }
 
-    if (output_style() == NESTED) indentation -= f->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation -= f->tabs();
 
     append_scope_closer();
 
@@ -297,7 +297,7 @@ namespace Sass {
       }
       return;
     }
-    if (output_style() == NESTED) indentation += m->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation += m->tabs();
     append_indentation();
     append_token("@media", m);
     append_mandatory_space();
@@ -311,7 +311,7 @@ namespace Sass {
       if (i < L - 1) append_special_linefeed();
     }
 
-    if (output_style() == NESTED) indentation -= m->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation -= m->tabs();
     append_scope_closer();
   }
 
@@ -380,7 +380,7 @@ namespace Sass {
   void Output::operator()(String_Constant* s)
   {
     std::string value(s->value());
-    if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
+    if (s->can_compress_whitespace() && output_style() == SASS_STYLE_COMPRESSED) {
       value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
     }
     if (!in_comment) {

data/ext/libsass/src/parser.cpp

@@ -76,18 +76,10 @@ namespace Sass {
     Block* root = SASS_MEMORY_NEW(ctx.mem, Block, pstate, 0, true);
     read_bom();
 
-    if (ctx.queue.size() == 1) {
-      is_root = true;
-      Import* pre = SASS_MEMORY_NEW(ctx.mem, Import, pstate);
-      std::string load_path(ctx.queue[0].load_path);
-      do_import(load_path, pre, ctx.c_headers, false);
-      ctx.head_imports = ctx.queue.size() - 1;
-      if (!pre->urls().empty()) (*root) << pre;
-      if (!pre->files().empty()) {
-        for (size_t i = 0, S = pre->files().size(); i < S; ++i) {
-          (*root) << SASS_MEMORY_NEW(ctx.mem, Import_Stub, pstate, pre->files()[i]);
-        }
-      }
+    // custom headers
+    if (ctx.resources.size() == 1) {
+    is_root = true;
+      ctx.apply_custom_headers(root, path, pstate);
     }
 
     block_stack.push_back(root);
@@ -113,6 +105,7 @@ namespace Sass {
 
     // parse comments before block
     // lex < optional_css_comments >();
+
     // lex mandatory opener or error out
     if (!lex_css < exactly<'{'> >()) {
       css_error("Invalid CSS", " after ", ": expected \"{\", was ");
@@ -130,7 +123,7 @@ namespace Sass {
     // update for end position
     block->update_pstate(pstate);
 
-    // parse comments before block
+    // parse comments after block
     // lex < optional_css_comments >();
 
     block_stack.pop_back();
@@ -222,11 +215,9 @@ namespace Sass {
       Import* imp = parse_import();
       // if it is a url, we only add the statement
       if (!imp->urls().empty()) (*block) << imp;
-      // if it is a file(s), we should process them
-      if (!imp->files().empty()) {
-        for (size_t i = 0, S = imp->files().size(); i < S; ++i) {
-          (*block) << SASS_MEMORY_NEW(ctx.mem, Import_Stub, pstate, imp->files()[i]);
-        }
+      // process all resources now (add Import_Stub nodes)
+      for (size_t i = 0, S = imp->incs().size(); i < S; ++i) {
+        (*block) << SASS_MEMORY_NEW(ctx.mem, Import_Stub, pstate, imp->incs()[i]);
       }
     }
 
@@ -288,105 +279,7 @@ namespace Sass {
   }
   // EO parse_block_nodes
 
-  void Parser::add_single_file (Import* imp, std::string import_path) {
-
-    std::string extension;
-    std::string unquoted(unquote(import_path));
-    if (unquoted.length() > 4) { // 2 quote marks + the 4 chars in .css
-      // a string constant is guaranteed to end with a quote mark, so make sure to skip it when indexing from the end
-      extension = unquoted.substr(unquoted.length() - 4, 4);
-    }
-
-    if (extension == ".css") {
-      String_Constant* loc = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, unquote(import_path));
-      Argument* loc_arg = SASS_MEMORY_NEW(ctx.mem, Argument, pstate, loc);
-      Arguments* loc_args = SASS_MEMORY_NEW(ctx.mem, Arguments, pstate);
-      (*loc_args) << loc_arg;
-      Function_Call* new_url = SASS_MEMORY_NEW(ctx.mem, Function_Call, pstate, "url", loc_args);
-      imp->urls().push_back(new_url);
-    }
-    else {
-      std::string current_dir = File::dir_name(path);
-      std::string resolved(ctx.add_file(current_dir, unquoted, *this));
-      if (resolved.empty()) error("file to import not found or unreadable: " + unquoted + "\nCurrent dir: " + current_dir, pstate);
-      imp->files().push_back(resolved);
-    }
-
-  }
-
-  void Parser::import_single_file (Import* imp, std::string import_path) {
-
-    if (imp->media_queries() ||
-        !unquote(import_path).substr(0, 7).compare("http://") ||
-        !unquote(import_path).substr(0, 8).compare("https://") ||
-        !unquote(import_path).substr(0, 2).compare("//"))
-    {
-      imp->urls().push_back(SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, import_path));
-    }
-    else {
-      add_single_file(imp, import_path);
-    }
-
-  }
-
-  bool Parser::do_import(const std::string& import_path, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one)
-  {
-    size_t i = 0;
-    bool has_import = false;
-    std::string load_path = unquote(import_path);
-    // std::cerr << "-- " << load_path << "\n";
-    for (Sass_Importer_Entry& importer : importers) {
-      // int priority = sass_importer_get_priority(importer);
-      Sass_Importer_Fn fn = sass_importer_get_function(importer);
-      if (Sass_Import_List includes =
-          fn(load_path.c_str(), importer, ctx.c_compiler)
-      ) {
-        Sass_Import_List list = includes;
-        while (*includes) { ++i;
-          std::string uniq_path = load_path;
-          if (!only_one && i) {
-            std::stringstream pathstrm;
-            pathstrm << uniq_path << ":" << i;
-            uniq_path = pathstrm.str();
-          }
-          Sass_Import_Entry include = *includes;
-          const char *abs_path = sass_import_get_abs_path(include);
-          char* source = sass_import_take_source(include);
-          size_t line = sass_import_get_error_line(include);
-          size_t column = sass_import_get_error_column(include);
-          const char* message = sass_import_get_error_message(include);
-          if (message) {
-            if (line == std::string::npos && column == std::string::npos) error(message, pstate);
-            else error(message, ParserState(message, source, Position(line, column)));
-          } else if (source) {
-            if (abs_path) {
-              ctx.add_source(uniq_path, abs_path, source);
-              imp->files().push_back(uniq_path);
-              size_t i = ctx.queue.size() - 1;
-              ctx.process_queue_entry(ctx.queue[i], i);
-            } else {
-              ctx.add_source(uniq_path, uniq_path, source);
-              imp->files().push_back(uniq_path);
-              size_t i = ctx.queue.size() - 1;
-              ctx.process_queue_entry(ctx.queue[i], i);
-            }
-          } else if(abs_path) {
-            import_single_file(imp, abs_path);
-          }
-          ++includes;
-        }
-        // deallocate returned memory
-        sass_delete_import_list(list);
-        // set success flag
-        has_import = true;
-        // break import chain
-        if (only_one) return true;
-      }
-    }
-    // return result
-    return has_import;
-  }
-
+  // parse imports inside the
   Import* Parser::parse_import()
   {
     Import* imp = SASS_MEMORY_NEW(ctx.mem, Import, pstate);
@@ -395,7 +288,7 @@ namespace Sass {
     do {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
-        if (!do_import(lexed, imp, ctx.c_importers, true))
+        if (!ctx.call_importers(unquote(std::string(lexed)), path, pstate, imp))
         {
           // push single file import
           // import_single_file(imp, lexed);
@@ -421,8 +314,7 @@ namespace Sass {
           error("malformed URL", pstate);
         }
         if (!lex< exactly<')'> >()) error("URI is missing ')'", pstate);
-        // imp->urls().push_back(result);
-        to_import.push_back(std::pair<std::string,Function_Call*>("", result));
+        to_import.push_back(std::pair<std::string, Function_Call*>("", result));
       }
       else {
         if (first) error("@import directive requires a url or quoted path", pstate);
@@ -440,7 +332,7 @@ namespace Sass {
       if (location.second) {
         imp->urls().push_back(location.second);
       } else {
-        import_single_file(imp, location.first);
+        ctx.import_url(imp, location.first, path);
       }
     }
 
@@ -1849,11 +1741,13 @@ namespace Sass {
     Block* block = parse_block();
     Block* alternative = 0;
 
-    if (lex< elseif_directive >()) {
+    // only throw away comment if we parse a case
+    // we want all other comments to be parsed
+    if (lex_css< elseif_directive >()) {
       alternative = SASS_MEMORY_NEW(ctx.mem, Block, pstate);
       (*alternative) << parse_if_directive(true);
     }
-    else if (lex< kwd_else_directive >()) {
+    else if (lex_css< kwd_else_directive >()) {
       alternative = parse_block();
     }
     return SASS_MEMORY_NEW(ctx.mem, If, if_source_position, predicate, block, alternative);
@@ -1969,15 +1863,15 @@ namespace Sass {
     Media_Query* media_query = SASS_MEMORY_NEW(ctx.mem, Media_Query, pstate);
 
     lex < css_comments >(false);
-    if (lex < word < not_kwd > >()) media_query->is_negated(true);
-    else if (lex < word < only_kwd > >()) media_query->is_restricted(true);
+    if (lex < kwd_not >()) media_query->is_negated(true);
+    else if (lex < kwd_only >()) media_query->is_restricted(true);
 
     lex < css_comments >(false);
     if (lex < identifier_schema >())  media_query->media_type(parse_identifier_schema());
     else if (lex < identifier >())    media_query->media_type(parse_interpolated_chunk(lexed));
     else                             (*media_query) << parse_media_expression();
 
-    while (lex_css < word < and_kwd > >()) (*media_query) << parse_media_expression();
+    while (lex_css < kwd_and >()) (*media_query) << parse_media_expression();
     if (lex < identifier_schema >()) {
       String_Schema* schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, pstate);
       *schema << media_query->media_type();
@@ -1985,7 +1879,7 @@ namespace Sass {
       *schema << parse_identifier_schema();
       media_query->media_type(schema);
     }
-    while (lex_css < word < and_kwd > >()) (*media_query) << parse_media_expression();
+    while (lex_css < kwd_and >()) (*media_query) << parse_media_expression();
     return media_query;
   }
 
@@ -2051,9 +1945,10 @@ namespace Sass {
     Supports_Condition* cond = parse_supports_condition_in_parens();
     if (!cond) return 0;
 
-    while (lex < kwd_and >() || lex < kwd_or >()) {
+    while (true) {
       Supports_Operator::Operand op = Supports_Operator::OR;
-      if (lexed.to_string() == "and") op = Supports_Operator::AND;
+      if (lex < kwd_and >()) { op = Supports_Operator::AND; }
+      else if(!lex < kwd_or >()) { break; }
 
       lex < css_whitespace >();
       Supports_Condition* right = parse_supports_condition_in_parens();
@@ -2159,6 +2054,9 @@ namespace Sass {
   At_Rule* Parser::parse_at_rule()
   {
     std::string kwd(lexed);
+
+    if (lexed == "@else") error("Invalid CSS: @else must come after @if", pstate);
+
     At_Rule* at_rule = SASS_MEMORY_NEW(ctx.mem, At_Rule, pstate, kwd);
     Lookahead lookahead = lookahead_for_include(position);
     if (lookahead.found && !lookahead.has_interpolants) {
@@ -2482,7 +2380,7 @@ namespace Sass {
 
   void Parser::error(std::string msg, Position pos)
   {
-    throw Error_Invalid(Error_Invalid::syntax, ParserState(path, source, pos.line ? pos : before_token, Offset(0, 0)), msg);
+    throw Exception::InvalidSass(ParserState(path, source, pos.line ? pos : before_token, Offset(0, 0)), msg);
   }
 
   // print a css parsing error with actual context information from parsed source

data/ext/libsass/src/parser.hpp

@@ -21,13 +21,9 @@ struct Lookahead {
 namespace Sass {
 
   class Parser : public ParserState {
-  private:
-    void add_single_file (Import* imp, std::string import_path);
-    void import_single_file (Import* imp, std::string import_path);
   public:
 
     enum Syntactic_Context { nothing, mixin_def, function_def };
-    bool do_import(const std::string& import_path, Import* imp, std::vector<Sass_Importer_Entry> importers, bool only_one = true);
 
     Context& ctx;
     std::vector<Block*> block_stack;

data/ext/libsass/src/prelexer.cpp

@@ -398,7 +398,7 @@ namespace Sass {
     }
     const char* elseif_directive(const char* src) {
       return sequence< exactly< else_kwd >,
-                                optional_css_whitespace,
+                                optional_css_comments,
                                 word< if_after_else_kwd > >(src);
     }
 
@@ -759,14 +759,17 @@ namespace Sass {
     const char* kwd_false(const char* src) {
       return word<false_kwd>(src);
     }
+    const char* kwd_only(const char* src) {
+      return keyword < only_kwd >(src);
+    }
     const char* kwd_and(const char* src) {
-      return word<and_kwd>(src);
+      return keyword < and_kwd >(src);
     }
     const char* kwd_or(const char* src) {
-      return word<or_kwd>(src);
+      return keyword < or_kwd >(src);
     }
     const char* kwd_not(const char* src) {
-      return word<not_kwd>(src);
+      return keyword < not_kwd >(src);
     }
     const char* kwd_eq(const char* src) {
       return exactly<eq>(src);
@@ -1016,7 +1019,7 @@ namespace Sass {
                            hex,
                            exactly<'|'>,
                            // exactly<'+'>,
-                           sequence < number, identifier >,
+                           sequence < number, unit_identifier >,
                            number,
                            sequence< exactly<'!'>, word<important_kwd> >
                           >(src);