sassc 1.8.1 → 1.8.2

data/ext/libsass/src/extend.cpp

@@ -1751,7 +1751,7 @@ namespace Sass {
           std::stringstream err;
           std::string cwd(Sass::File::get_cwd());
           ParserState pstate(ext.second->pstate());
-          std::string rel_path(Sass::File::resolve_relative_path(pstate.path, cwd, cwd));
+          std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
           err << "You may not @extend an outer selector from within @media.\n";
           err << "You may only @extend selectors within the same directive.\n";
           err << "From \"@extend " << ext.second->perform(&to_string) << "\"";

data/ext/libsass/src/file.cpp

@@ -126,7 +126,7 @@ namespace Sass {
       else return path.substr(pos+1);
     }
 
-    // do a locigal clean up of the path
+    // do a logical clean up of the path
     // no physical check on the filesystem
     std::string make_canonical_path (std::string path)
     {
@@ -192,59 +192,71 @@ namespace Sass {
       return l + r;
     }
 
+    std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path)
+    {
+      // magic algorith goes here!!
+
+      // if the file is outside this directory show the absolute path
+      if (rel_path.substr(0, 3) == "../") {
+        return orig_path;
+      }
+      // this seems to work most of the time
+      return abs_path == orig_path ? abs_path : rel_path;
+    }
+
     // create an absolute path by resolving relative paths with cwd
-    std::string make_absolute_path(const std::string& path, const std::string& cwd)
+    std::string rel2abs(const std::string& path, const std::string& base, const std::string& cwd)
     {
-      return make_canonical_path((is_absolute_path(path) ? path : join_paths(cwd, path)));
+      return make_canonical_path(join_paths(join_paths(cwd, base), path));
     }
 
     // create a path that is relative to the given base directory
     // path and base will first be resolved against cwd to make them absolute
-    std::string resolve_relative_path(const std::string& uri, const std::string& base, const std::string& cwd)
+    std::string abs2rel(const std::string& path, const std::string& base, const std::string& cwd)
     {
 
-      std::string absolute_uri = make_absolute_path(uri, cwd);
-      std::string absolute_base = make_absolute_path(base, cwd);
+      std::string abs_path = rel2abs(path, cwd);
+      std::string abs_base = rel2abs(base, cwd);
 
       size_t proto = 0;
       // check if we have a protocol
-      if (uri[proto] && Prelexer::is_alpha(uri[proto])) {
+      if (path[proto] && Prelexer::is_alpha(path[proto])) {
         // skip over all alphanumeric characters
-        while (uri[proto] && Prelexer::is_alnum(uri[proto++])) {}
+        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
         // then skip over the mandatory colon
-        if (proto && uri[proto] == ':') ++ proto;
+        if (proto && path[proto] == ':') ++ proto;
       }
 
       // distinguish between windows absolute paths and valid protocols
       // we assume that protocols must at least have two chars to be valid
-      if (proto && uri[proto++] == '/' && proto > 3) return uri;
+      if (proto && path[proto++] == '/' && proto > 3) return path;
 
       #ifdef _WIN32
         // absolute link must have a drive letter, and we know that we
         // can only create relative links if both are on the same drive
-        if (absolute_base[0] != absolute_uri[0]) return absolute_uri;
+        if (abs_base[0] != abs_path[0]) return abs_path;
       #endif
 
       std::string stripped_uri = "";
       std::string stripped_base = "";
 
       size_t index = 0;
-      size_t minSize = std::min(absolute_uri.size(), absolute_base.size());
+      size_t minSize = std::min(abs_path.size(), abs_base.size());
       for (size_t i = 0; i < minSize; ++i) {
         #ifdef FS_CASE_SENSITIVE
-          if (absolute_uri[i] != absolute_base[i]) break;
+          if (abs_path[i] != abs_base[i]) break;
         #else
           // compare the charactes in a case insensitive manner
           // windows fs is only case insensitive in ascii ranges
-          if (tolower(absolute_uri[i]) != tolower(absolute_base[i])) break;
+          if (tolower(abs_path[i]) != tolower(abs_base[i])) break;
         #endif
-        if (absolute_uri[i] == '/') index = i + 1;
+        if (abs_path[i] == '/') index = i + 1;
       }
-      for (size_t i = index; i < absolute_uri.size(); ++i) {
-        stripped_uri += absolute_uri[i];
+      for (size_t i = index; i < abs_path.size(); ++i) {
+        stripped_uri += abs_path[i];
       }
-      for (size_t i = index; i < absolute_base.size(); ++i) {
-        stripped_base += absolute_base[i];
+      for (size_t i = index; i < abs_base.size(); ++i) {
+        stripped_base += abs_base[i];
       }
 
       size_t left = 0;
@@ -278,7 +290,7 @@ namespace Sass {
     // (2) underscore + given
     // (3) underscore + given + extension
     // (4) given + extension
-    std::vector<Sass_Queued> resolve_file(const std::string& root, const std::string& file)
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file)
     {
       std::string filename = join_paths(root, file);
       // supported extensions
@@ -288,29 +300,29 @@ namespace Sass {
       // split the filename
       std::string base(dir_name(file));
       std::string name(base_name(file));
-      std::vector<Sass_Queued> resolved;
+      std::vector<Include> includes;
       // create full path (maybe relative)
       std::string rel_path(join_paths(base, name));
       std::string abs_path(join_paths(root, rel_path));
-      if (file_exists(abs_path)) resolved.push_back(Sass_Queued(rel_path, abs_path, 0));
+      if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       // next test variation with underscore
       rel_path = join_paths(base, "_" + name);
       abs_path = join_paths(root, rel_path);
-      if (file_exists(abs_path)) resolved.push_back(Sass_Queued(rel_path, abs_path, 0));
+      if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       // next test exts plus underscore
       for(auto ext : exts) {
         rel_path = join_paths(base, "_" + name + ext);
         abs_path = join_paths(root, rel_path);
-        if (file_exists(abs_path)) resolved.push_back(Sass_Queued(rel_path, abs_path, 0));
+        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       }
       // next test plain name with exts
       for(auto ext : exts) {
         rel_path = join_paths(base, name + ext);
         abs_path = join_paths(root, rel_path);
-        if (file_exists(abs_path)) resolved.push_back(Sass_Queued(rel_path, abs_path, 0));
+        if (file_exists(abs_path)) includes.push_back({{ rel_path, root }, abs_path });
       }
       // nothing found
-      return resolved;
+      return includes;
     }
 
     // helper function to resolve a filename
@@ -319,7 +331,7 @@ namespace Sass {
       // search in every include path for a match
       for (size_t i = 0, S = paths.size(); i < S; ++i)
       {
-        std::vector<Sass_Queued> resolved(resolve_file(paths[i], file));
+        std::vector<Include> resolved(resolve_includes(paths[i], file));
         if (resolved.size()) return resolved[0].abs_path;
       }
       // nothing found

data/ext/libsass/src/file.hpp

@@ -6,16 +6,9 @@
 
 namespace Sass {
 
+  class Block;
   class Context;
 
-  struct Sass_Queued {
-    std::string abs_path;
-    std::string load_path;
-    const char* source;
-  public:
-    Sass_Queued(const std::string& load_path, const std::string& abs_path, const char* source);
-  };
-
   namespace File {
 
     // return the current directory
@@ -43,15 +36,16 @@ namespace Sass {
     // but only if right side is not absolute yet
     std::string join_paths(std::string root, std::string name);
 
+    // if the relative path is outside of the cwd we want want to
+    // show the absolute path in console messages
+    std::string path_for_console(const std::string& rel_path, const std::string& abs_path, const std::string& orig_path);
+
     // create an absolute path by resolving relative paths with cwd
-    std::string make_absolute_path(const std::string& path, const std::string& cwd = ".");
+    std::string rel2abs(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
 
     // create a path that is relative to the given base directory
     // path and base will first be resolved against cwd to make them absolute
-    std::string resolve_relative_path(const std::string& path, const std::string& base, const std::string& cwd = ".");
-
-    // try to find/resolve the filename
-    std::vector<Sass_Queued> resolve_file(const std::string& root, const std::string& file);
+    std::string abs2rel(const std::string& path, const std::string& base = ".", const std::string& cwd = get_cwd());
 
     // helper function to resolve a filename
     std::string find_file(const std::string& file, const std::vector<std::string> paths);
@@ -64,6 +58,66 @@ namespace Sass {
     char* read_file(const std::string& file);
 
   }
+
+  // requested import
+  class Importer {
+    public:
+      // requested import path
+      std::string imp_path;
+      // parent context path
+      std::string ctx_path;
+      // base derived from context path
+      // this really just acts as a cache
+      std::string base_path;
+    public:
+      Importer(std::string imp_path, std::string ctx_path)
+      : imp_path(File::make_canonical_path(imp_path)),
+        ctx_path(File::make_canonical_path(ctx_path)),
+        base_path(File::dir_name(ctx_path))
+      { }
+  };
+
+  // a resolved include (final import)
+  class Include : public Importer {
+    public:
+      // resolved absolute path
+      std::string abs_path;
+    public:
+      Include(const Importer& imp, std::string abs_path)
+      : Importer(imp), abs_path(abs_path)
+      { }
+  };
+
+  // a loaded resource
+  class Resource {
+    public:
+      // the file contents
+      char* contents;
+      // conected sourcemap
+      char* srcmap;
+    public:
+      Resource(char* contents, char* srcmap)
+      : contents(contents), srcmap(srcmap)
+      { }
+  };
+
+  // parsed stylesheet from loaded resource
+  class StyleSheet : public Resource {
+    public:
+      // parsed root block
+      Block* root;
+    public:
+      StyleSheet(const Resource& res, Block* root)
+      : Resource(res), root(root)
+      { }
+  };
+
+  namespace File {
+
+    std::vector<Include> resolve_includes(const std::string& root, const std::string& file);
+
+  }
+
 }
 
 #endif

data/ext/libsass/src/functions.cpp

@@ -11,9 +11,9 @@
 #include "util.hpp"
 #include "expand.hpp"
 #include "utf8_string.hpp"
+#include "sass/base.h"
 #include "utf8.h"
 
-#include <atomic>
 #include <cstdlib>
 #include <cmath>
 #include <cctype>
@@ -311,9 +311,9 @@ namespace Sass {
 
       return SASS_MEMORY_NEW(ctx.mem, Color,
                              pstate,
-                             std::round(w1*color1->r() + w2*color2->r()),
-                             std::round(w1*color1->g() + w2*color2->g()),
-                             std::round(w1*color1->b() + w2*color2->b()),
+                             Sass::round(w1*color1->r() + w2*color2->r()),
+                             Sass::round(w1*color1->g() + w2*color2->g()),
+                             Sass::round(w1*color1->b() + w2*color2->b()),
                              color1->a()*p + color2->a()*(1-p));
     }
 
@@ -331,7 +331,7 @@ namespace Sass {
 
       double max = std::max(r, std::max(g, b));
       double min = std::min(r, std::min(g, b));
-      double del = max - min;
+      double delta = max - min;
 
       double h = 0, s = 0, l = (max + min) / 2.0;
 
@@ -339,12 +339,12 @@ namespace Sass {
         h = s = 0; // achromatic
       }
       else {
-        if (l < 0.5) s = del / (max + min);
-        else         s = del / (2.0 - max - min);
+        if (l < 0.5) s = delta / (max + min);
+        else         s = delta / (2.0 - max - min);
 
-        if      (r == max) h = (g - b) / del + (g < b ? 6 : 0);
-        else if (g == max) h = (b - r) / del + 2;
-        else if (b == max) h = (r - g) / del + 4;
+        if      (r == max) h = (g - b) / delta + (g < b ? 6 : 0);
+        else if (g == max) h = (b - r) / delta + 2;
+        else if (b == max) h = (r - g) / delta + 4;
       }
 
       HSL hsl_struct;
@@ -357,8 +357,8 @@ namespace Sass {
 
     // hue to RGB helper function
     double h_to_rgb(double m1, double m2, double h) {
-      if (h < 0) h += 1;
-      if (h > 1) h -= 1;
+      while (h < 0) h += 1;
+      while (h > 1) h -= 1;
       if (h*6.0 < 1) return m1 + (m2 - m1)*h*6;
       if (h*2.0 < 1) return m2;
       if (h*3.0 < 2) return m1 + (m2 - m1) * (2.0/3.0 - h)*6;
@@ -384,9 +384,9 @@ namespace Sass {
       else m2 = (l+s)-(l*s);
       double m1 = (l*2.0)-m2;
       // round the results -- consider moving this into the Color constructor
-      double r = (h_to_rgb(m1, m2, h+1.0/3.0) * 255.0);
+      double r = (h_to_rgb(m1, m2, h + 1.0/3.0) * 255.0);
       double g = (h_to_rgb(m1, m2, h) * 255.0);
-      double b = (h_to_rgb(m1, m2, h-1.0/3.0) * 255.0);
+      double b = (h_to_rgb(m1, m2, h - 1.0/3.0) * 255.0);
 
       return SASS_MEMORY_NEW(ctx.mem, Color, pstate, r, g, b, a);
     }
@@ -854,10 +854,10 @@ namespace Sass {
 
       std::stringstream ss;
       ss << '#' << std::setw(2) << std::setfill('0');
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(a+0.5));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(r+0.5));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(g+0.5));
-      ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(b+0.5));
+      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(a));
+      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(r));
+      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g));
+      ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b));
 
       std::string result(ss.str());
       for (size_t i = 0, L = result.length(); i < L; ++i) {
@@ -874,10 +874,7 @@ namespace Sass {
     BUILT_IN(sass_unquote)
     {
       AST_Node* arg = env["$string"];
-      if (dynamic_cast<Null*>(arg)) {
-        return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
-      }
-      else if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
+      if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
         String_Constant* result = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, string_quoted->value());
         // remember if the string was quoted (color tokens)
         result->sass_fix_1291(string_quoted->quote_mark() != 0);
@@ -887,9 +884,11 @@ namespace Sass {
         return (Expression*) arg;
       }
       else {
-        To_String to_string(&ctx);
+        To_String to_string(&ctx, false, true);
         std::string val(arg->perform(&to_string));
-        deprecated("Passing " + val + ", a non-string value, to unquote()", pstate);
+        val = dynamic_cast<Null*>(arg) ? "null" : val;
+
+        deprecated_function("Passing " + val + ", a non-string value, to unquote()", pstate);
         return (Expression*) arg;
       }
     }
@@ -1089,7 +1088,7 @@ namespace Sass {
       Number* n = ARG("$number", Number);
       Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
-      r->value(std::floor(r->value() + 0.5));
+      r->value(Sass::round(r->value()));
       return r;
     }
 
@@ -1156,7 +1155,10 @@ namespace Sass {
     Signature random_sig = "random($limit:false)";
     BUILT_IN(random)
     {
-      Number* l = dynamic_cast<Number*>(env["$limit"]);
+      AST_Node* arg = env["$limit"];
+      Value* v = dynamic_cast<Value*>(arg);
+      Number* l = dynamic_cast<Number*>(arg);
+      Boolean* b = dynamic_cast<Boolean*>(arg);
       if (l) {
         double v = l->value();
         if (v < 1) {
@@ -1174,11 +1176,16 @@ namespace Sass {
         uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
         return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)distributed);
       }
-      else {
+      else if (b) {
         std::uniform_real_distribution<> distributor(0, 1);
         double distributed = static_cast<double>(distributor(rand));
         return SASS_MEMORY_NEW(ctx.mem, Number, pstate, distributed);
-     }
+      } else if (v) {
+        throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number", v);
+      } else {
+        throw Exception::InvalidArgumentType(pstate, "random", "$limit", "number");
+      }
+      return 0;
     }
 
     /////////////////
@@ -1668,13 +1675,13 @@ namespace Sass {
       } else {
         bool parentheses = v->concrete_type() == Expression::MAP ||
                            v->concrete_type() == Expression::LIST;
-        Output_Style old_style;
-        old_style = ctx.output_style;
-        ctx.output_style = NESTED;
+        Sass_Output_Style old_style;
+        old_style = ctx.c_options->output_style;
+        ctx.c_options->output_style = SASS_STYLE_NESTED;
         To_String to_string(&ctx, false);
         std::string inspect = v->perform(&to_string);
         if (inspect.empty() && parentheses) inspect = "()";
-        ctx.output_style = old_style;
+        ctx.c_options->output_style = old_style;
         return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, inspect);
       }
       // return v;

data/ext/libsass/src/inspect.cpp

@@ -26,11 +26,11 @@ namespace Sass {
       add_open_mapping(block);
       append_scope_opener();
     }
-    if (output_style() == NESTED) indentation += block->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation += block->tabs();
     for (size_t i = 0, L = block->length(); i < L; ++i) {
       (*block)[i]->perform(this);
     }
-    if (output_style() == NESTED) indentation -= block->tabs();
+    if (output_style() == SASS_STYLE_NESTED) indentation -= block->tabs();
     if (!block->is_root()) {
       append_scope_closer();
       add_close_mapping(block);
@@ -123,7 +123,7 @@ namespace Sass {
     if (dec->value()->concrete_type() == Expression::NULL_VAL) return;
     bool was_decl = in_declaration;
     in_declaration = true;
-    if (output_style() == NESTED)
+    if (output_style() == SASS_STYLE_NESTED)
       indentation += dec->tabs();
     append_indentation();
     dec->property()->perform(this);
@@ -141,7 +141,7 @@ namespace Sass {
       append_string("!important");
     }
     append_delimiter();
-    if (output_style() == NESTED)
+    if (output_style() == SASS_STYLE_NESTED)
       indentation -= dec->tabs();
     in_declaration = was_decl;
   }
@@ -198,7 +198,7 @@ namespace Sass {
     append_indentation();
     append_token("@import", import);
     append_mandatory_space();
-    append_string(import->file_name());
+    append_string(import->imp_path());
     append_delimiter();
   }
 
@@ -363,7 +363,7 @@ namespace Sass {
   void Inspect::operator()(List* list)
   {
     std::string sep(list->separator() == SASS_SPACE ? " " : ",");
-    if (output_style() != COMPRESSED && sep == ",") sep += " ";
+    if ((output_style() != SASS_STYLE_COMPRESSED || in_debug) && sep == ",") sep += " ";
     else if (in_media_block && sep != " ") sep += " "; // verified
     if (list->empty()) return;
     bool items_output = false;
@@ -459,8 +459,8 @@ namespace Sass {
   void Inspect::operator()(Number* n)
   {
     // use values to_string facility
-    bool compressed = ctx->output_style == COMPRESSED;
-    std::string res = n->to_string(compressed, (int)ctx->precision);
+    bool compressed = ctx->output_style() == SASS_STYLE_COMPRESSED;
+    std::string res(n->to_string(compressed, (int)ctx->c_options->precision));
     // output the final token
     append_token(res, n);
   }
@@ -468,8 +468,8 @@ namespace Sass {
   void Inspect::operator()(Color* c)
   {
     // use values to_string facility
-    bool compressed = ctx->output_style == COMPRESSED;
-	std::string res = c->to_string(compressed, (int)ctx->precision);
+    bool compressed = ctx->output_style() == SASS_STYLE_COMPRESSED;
+    std::string res(c->to_string(compressed, (int)ctx->c_options->precision));
     // output the final token
     append_token(res, c);
   }
@@ -477,8 +477,8 @@ namespace Sass {
   void Inspect::operator()(Boolean* b)
   {
     // use values to_string facility
-    bool compressed = ctx->output_style == COMPRESSED;
-	std::string res = b->to_string(compressed, (int)ctx->precision);
+    bool compressed = ctx->output_style() == SASS_STYLE_COMPRESSED;
+    std::string res(b->to_string(compressed, (int)ctx->c_options->precision));
     // output the final token
     append_token(res, b);
   }
@@ -497,8 +497,8 @@ namespace Sass {
   void Inspect::operator()(String_Constant* s)
   {
     // get options from optional? context
-    int precision = ctx ? (int)ctx->precision : 5;
-    bool compressed = ctx ? ctx->output_style == COMPRESSED : false;
+    int precision = ctx ? (int)ctx->c_options->precision : 5;
+    bool compressed = ctx ? ctx->output_style() == SASS_STYLE_COMPRESSED : false;
     // use values to_string facility
     std::string res(s->to_string(compressed, precision));
     // output the final token
@@ -508,8 +508,8 @@ namespace Sass {
   void Inspect::operator()(String_Quoted* s)
   {
     // get options from optional? context
-    int precision = ctx ? (int)ctx->precision : 5;
-    bool compressed = ctx ? ctx->output_style == COMPRESSED : false;
+    int precision = ctx ? (int)ctx->c_options->precision : 5;
+    bool compressed = ctx ? ctx->output_style() == SASS_STYLE_COMPRESSED : false;
     // use values to_string facility
     std::string res(s->to_string(compressed, precision));
     // output the final token
@@ -612,8 +612,8 @@ namespace Sass {
   void Inspect::operator()(Null* n)
   {
     // use values to_string facility
-    bool compressed = ctx->output_style == COMPRESSED;
-    std::string res = n->to_string(compressed, (int)ctx->precision);
+    bool compressed = output_style() == SASS_STYLE_COMPRESSED;
+    std::string res(n->to_string(compressed, (int)ctx->c_options->precision));
     // output the final token
     append_token(res, n);
   }
@@ -752,7 +752,7 @@ namespace Sass {
       (*s)[i]->perform(this);
     }
     if (s->has_line_break()) {
-      if (output_style() != COMPACT) {
+      if (output_style() != SASS_STYLE_COMPACT) {
         append_optional_linefeed();
       }
     }
@@ -774,7 +774,7 @@ namespace Sass {
     if (head && head->length() != 0) head->perform(this);
     bool is_empty = !head || head->length() == 0 || head->is_empty_reference();
     bool is_tail = head && !head->is_empty_reference() && tail;
-    if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;
+    if (output_style() == SASS_STYLE_COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;
 
     switch (comb) {
       case Complex_Selector::ANCESTOR_OF:
@@ -810,7 +810,7 @@ namespace Sass {
     }
     if (tail) tail->perform(this);
     if (!tail && c->has_line_break()) {
-      if (output_style() == COMPACT) {
+      if (output_style() == SASS_STYLE_COMPACT) {
         append_mandatory_space();
       }
     }