sassc 1.8.3 → 1.8.4

data/ext/libsass/src/remove_placeholders.hpp

@@ -17,11 +17,12 @@ namespace Sass {
 
         void fallback_impl(AST_Node* n) {}
 
+    private:
+      Selector_List* remove_placeholders(Selector_List*);
+
     public:
         Remove_Placeholders(Context&);
-        virtual ~Remove_Placeholders() { }
-
-        using Operation<void>::operator();
+        ~Remove_Placeholders() { }
 
         void operator()(Block*);
         void operator()(Ruleset*);

data/ext/libsass/src/sass.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cstdlib>
 #include <cstring>
 #include <vector>

data/ext/libsass/src/sass.hpp

@@ -0,0 +1,129 @@
+// must be the first include in all compile units
+#ifndef SASS_SASS_H
+#define SASS_SASS_H
+
+// undefine extensions macro to tell sys includes
+// that we do not want any macros to be exported
+// mainly fixes an issue on SmartOS (SEC macro)
+#undef __EXTENSIONS__
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4005)
+#endif
+
+// aplies to MSVC and MinGW
+#ifdef _WIN32
+// we do not want the ERROR macro
+# define NOGDI
+// we do not want the min/max macro
+# define NOMINMAX
+// we do not want the IN/OUT macro
+# define _NO_W32_PSEUDO_MODIFIERS
+#endif
+
+
+// should we be case insensitive
+// when dealing with files or paths
+#ifndef FS_CASE_SENSITIVE
+# ifdef _WIN32
+#  define FS_CASE_SENSITIVE 0
+# else
+#  define FS_CASE_SENSITIVE 1
+# endif
+#endif
+
+// path separation char
+#ifndef PATH_SEP
+# ifdef _WIN32
+#  define PATH_SEP ';'
+# else
+#  define PATH_SEP ':'
+# endif
+#endif
+
+
+// include C-API header
+#include "sass/base.h"
+
+// output behaviours
+namespace Sass {
+
+  // create some C++ aliases for the most used options
+  const static Sass_Output_Style NESTED = SASS_STYLE_NESTED;
+  const static Sass_Output_Style COMPACT = SASS_STYLE_COMPACT;
+  const static Sass_Output_Style EXPANDED = SASS_STYLE_EXPANDED;
+  const static Sass_Output_Style COMPRESSED = SASS_STYLE_COMPRESSED;
+  // only used internal to trigger ruby inspect behavior
+  const static Sass_Output_Style INSPECT = SASS_STYLE_INSPECT;
+  const static Sass_Output_Style TO_SASS = SASS_STYLE_TO_SASS;
+
+};
+
+// input behaviours
+enum Sass_Input_Style {
+  SASS_CONTEXT_NULL,
+  SASS_CONTEXT_FILE,
+  SASS_CONTEXT_DATA,
+  SASS_CONTEXT_FOLDER
+};
+
+// simple linked list
+struct string_list {
+  string_list* next;
+  char* string;
+};
+
+// sass config options structure
+struct Sass_Inspect_Options {
+
+  // Output style for the generated css code
+  // A value from above SASS_STYLE_* constants
+  enum Sass_Output_Style output_style;
+
+  // Precision for fractional numbers
+  int precision;
+
+  // initialization list (constructor with defaults)
+  Sass_Inspect_Options(Sass_Output_Style style = Sass::NESTED,
+                       int precision = 5)
+  : output_style(style), precision(precision)
+  { }
+
+};
+
+// sass config options structure
+struct Sass_Output_Options : Sass_Inspect_Options {
+
+  // String to be used for indentation
+  const char* indent;
+  // String to be used to for line feeds
+  const char* linefeed;
+
+  // Emit comments in the generated CSS indicating
+  // the corresponding source line.
+  bool source_comments;
+
+  // initialization list (constructor with defaults)
+  Sass_Output_Options(struct Sass_Inspect_Options opt,
+                      const char* indent = "  ",
+                      const char* linefeed = "\n",
+                      bool source_comments = false)
+  : Sass_Inspect_Options(opt),
+    indent(indent), linefeed(linefeed),
+    source_comments(source_comments)
+  { }
+
+  // initialization list (constructor with defaults)
+  Sass_Output_Options(Sass_Output_Style style = Sass::NESTED,
+                      int precision = 5,
+                      const char* indent = "  ",
+                      const char* linefeed = "\n",
+                      bool source_comments = false)
+  : Sass_Inspect_Options(style, precision),
+    indent(indent), linefeed(linefeed),
+    source_comments(source_comments)
+  { }
+
+};
+
+#endif

data/ext/libsass/src/sass_context.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cstring>
 #include <stdexcept>
 #include <sstream>
@@ -10,6 +11,7 @@
 #include "util.hpp"
 #include "context.hpp"
 #include "sass_context.hpp"
+#include "sass_functions.hpp"
 #include "ast_fwd_decl.hpp"
 #include "error_handling.hpp"
 
@@ -41,11 +43,10 @@ extern "C" {
     catch (Exception::Base& e) {
       std::stringstream msg_stream;
       std::string cwd(Sass::File::get_cwd());
-      std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
 
-      std::string msg_prefix("Error: ");
+      std::string msg_prefix(e.errtype());
       bool got_newline = false;
-      msg_stream << msg_prefix;
+      msg_stream << msg_prefix << ": ";
       const char* msg = e.what();
       while(msg && *msg) {
         if (*msg == '\r') {
@@ -53,15 +54,26 @@ extern "C" {
         } else if (*msg == '\n') {
           got_newline = true;
         } else if (got_newline) {
-          msg_stream << std::string(msg_prefix.size(), ' ');
+          msg_stream << std::string(msg_prefix.size() + 2, ' ');
           got_newline = false;
         }
         msg_stream << *msg;
         ++ msg;
       }
       if (!got_newline) msg_stream << "\n";
-      msg_stream << std::string(msg_prefix.size(), ' ');
-      msg_stream << " on line " << e.pstate.line+1 << " of " << rel_path << "\n";
+      if (e.import_stack) {
+        for (size_t i = 1; i < e.import_stack->size() - 1; ++i) {
+          std::string path((*e.import_stack)[i]->imp_path);
+          std::string rel_path(Sass::File::abs2rel(path, cwd, cwd));
+          msg_stream << std::string(msg_prefix.size() + 2, ' ');
+          msg_stream << (i == 1 ? " on line " : " from line ");
+          msg_stream << e.pstate.line+1 << " of " << rel_path << "\n";
+        }
+      } else {
+        std::string rel_path(Sass::File::abs2rel(e.pstate.path, cwd, cwd));
+        msg_stream << std::string(msg_prefix.size() + 2, ' ');
+        msg_stream << " on line " << e.pstate.line+1 << " of " << rel_path << "\n";
+      }
 
       // now create the code trace (ToDo: maybe have util functions?)
       if (e.pstate.line != std::string::npos && e.pstate.column != std::string::npos) {
@@ -111,6 +123,7 @@ extern "C" {
       msg_stream << "Unable to allocate memory: " << ba.what() << std::endl;
       json_append_member(json_err, "status", json_mknumber(2));
       json_append_member(json_err, "message", json_mkstring(ba.what()));
+      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_text = sass_strdup(ba.what());
@@ -122,9 +135,10 @@ extern "C" {
     catch (std::exception& e) {
       std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Error: " << e.what() << std::endl;
+      msg_stream << "Internal Error: " << e.what() << std::endl;
       json_append_member(json_err, "status", json_mknumber(3));
       json_append_member(json_err, "message", json_mkstring(e.what()));
+      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_text = sass_strdup(e.what());
@@ -136,9 +150,10 @@ extern "C" {
     catch (std::string& e) {
       std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Error: " << e << std::endl;
+      msg_stream << "Internal Error: " << e << std::endl;
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e.c_str()));
+      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_text = sass_strdup(e.c_str());
@@ -150,9 +165,10 @@ extern "C" {
     catch (const char* e) {
       std::stringstream msg_stream;
       JsonNode* json_err = json_mkobject();
-      msg_stream << "Error: " << e << std::endl;
+      msg_stream << "Internal Error: " << e << std::endl;
       json_append_member(json_err, "status", json_mknumber(4));
       json_append_member(json_err, "message", json_mkstring(e));
+      json_append_member(json_err, "formatted", json_mkstring(msg_stream.str().c_str()));
       c_ctx->error_json = json_stringify(json_err, "  ");;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_text = sass_strdup(e);
@@ -398,14 +414,14 @@ extern "C" {
   struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx)
   {
     if (data_ctx == 0) return 0;
-    Context* cpp_ctx = new Data_Context(data_ctx);
+    Context* cpp_ctx = new Data_Context(*data_ctx);
     return sass_prepare_context(data_ctx, cpp_ctx);
   }
 
   struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* file_ctx)
   {
     if (file_ctx == 0) return 0;
-    Context* cpp_ctx = new File_Context(file_ctx);
+    Context* cpp_ctx = new File_Context(*file_ctx);
     return sass_prepare_context(file_ctx, cpp_ctx);
   }
 
@@ -416,10 +432,11 @@ extern "C" {
       return data_ctx->error_status;
     try {
       if (data_ctx->source_string == 0) { throw(std::runtime_error("Data context has no source string")); }
-      if (*data_ctx->source_string == 0) { throw(std::runtime_error("Data context has empty source string")); }
+      // empty source string is a valid case, even if not really usefull (different than with file context)
+      // if (*data_ctx->source_string == 0) { throw(std::runtime_error("Data context has empty source string")); }
     }
     catch (...) { return handle_errors(data_ctx) | 1; }
-    Context* cpp_ctx = new Data_Context(data_ctx);
+    Context* cpp_ctx = new Data_Context(*data_ctx);
     return sass_compile_context(data_ctx, cpp_ctx);
   }
 
@@ -433,7 +450,7 @@ extern "C" {
       if (*file_ctx->input_path == 0) { throw(std::runtime_error("File context has empty input path")); }
     }
     catch (...) { return handle_errors(file_ctx) | 1; }
-    Context* cpp_ctx = new File_Context(file_ctx);
+    Context* cpp_ctx = new File_Context(*file_ctx);
     return sass_compile_context(file_ctx, cpp_ctx);
   }
 

data/ext/libsass/src/sass_context.hpp

@@ -2,36 +2,12 @@
 #define SASS_SASS_CONTEXT_H
 
 #include "sass.h"
+#include "sass.hpp"
 #include "context.hpp"
 #include "ast_fwd_decl.hpp"
 
-// Input behaviours
-enum Sass_Input_Style {
-  SASS_CONTEXT_NULL,
-  SASS_CONTEXT_FILE,
-  SASS_CONTEXT_DATA,
-  SASS_CONTEXT_FOLDER
-};
-
-// simple linked list
-struct string_list {
-  string_list* next;
-  char* string;
-};
-
 // sass config options structure
-struct Sass_Options {
-
-  // Precision for fractional numbers
-  int precision;
-
-  // Output style for the generated css code
-  // A value from above SASS_STYLE_* constants
-  enum Sass_Output_Style output_style;
-
-  // Emit comments in the generated CSS indicating
-  // the corresponding source line.
-  bool source_comments;
+struct Sass_Options : Sass_Output_Options {
 
   // embed sourceMappingUrl as data uri
   bool source_map_embed;
@@ -59,11 +35,6 @@ struct Sass_Options {
   // information in source-maps etc.
   char* output_path;
 
-  // String to be used for indentation
-  const char* indent;
-  // String to be used to for line feeds
-  const char* linefeed;
-
   // Colon-separated list of paths
   // Semicolon-separated on Windows
   // Maybe use array interface instead?

data/ext/libsass/src/sass_functions.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cstring>
 #include "util.hpp"
 #include "context.hpp"

data/ext/libsass/src/sass_interface.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <string>
 #include <cstdlib>
 #include <cstring>
@@ -69,9 +70,8 @@ extern "C" {
       else {
           output_path = c_ctx->output_path;
       }
-      Data_Context cpp_ctx(
-        (Sass_Data_Context*) 0
-      );
+      struct Sass_Data_Context opt;
+      Data_Context cpp_ctx(opt);
       if (c_ctx->c_functions) {
         Sass_Function_List this_func_data = c_ctx->c_functions;
         while ((this_func_data) && (*this_func_data)) {
@@ -145,9 +145,8 @@ extern "C" {
       else {
           output_path = c_ctx->output_path;
       }
-      File_Context cpp_ctx(
-        (Sass_File_Context*) 0
-      );
+      struct Sass_File_Context opt;
+      File_Context cpp_ctx(opt);
       if (c_ctx->c_functions) {
         Sass_Function_List this_func_data = c_ctx->c_functions;
         while ((this_func_data) && (*this_func_data)) {

data/ext/libsass/src/sass_util.cpp

@@ -1,5 +1,5 @@
+#include "sass.hpp"
 #include "node.hpp"
-#include "to_string.hpp"
 
 namespace Sass {
 
@@ -38,7 +38,6 @@ namespace Sass {
     end
   */
   Node paths(const Node& arrs, Context& ctx) {
-    To_String to_string(&ctx);
 
     Node loopStart = Node::createCollection();
     loopStart.collection()->push_back(Node::createCollection());

data/ext/libsass/src/sass_util.hpp

@@ -221,28 +221,28 @@ namespace Sass {
 
     std::map<unsigned int, KeyType> order;
 
-    std::map<KeyType, std::vector<EnumType> > grouped;
+    std::map<size_t, std::vector<EnumType> > grouped;
 
     for (typename std::vector<EnumType>::iterator enumIter = enumeration.begin(), enumIterEnd = enumeration.end(); enumIter != enumIterEnd; enumIter++) {
       EnumType& e = *enumIter;
 
       KeyType key = keyFunc(e);
 
-      if (grouped.find(key) == grouped.end()) {
+      if (grouped.find(key.hash()) == grouped.end()) {
         order.insert(std::make_pair((unsigned int)order.size(), key));
 
         std::vector<EnumType> newCollection;
         newCollection.push_back(e);
-        grouped.insert(std::make_pair(key, newCollection));
+        grouped.insert(std::make_pair(key.hash(), newCollection));
       } else {
-        std::vector<EnumType>& collection = grouped.at(key);
+        std::vector<EnumType>& collection = grouped.at(key.hash());
         collection.push_back(e);
       }
     }
 
     for (unsigned int index = 0; index < order.size(); index++) {
       KeyType& key = order.at(index);
-      std::vector<EnumType>& values = grouped.at(key);
+      std::vector<EnumType>& values = grouped.at(key.hash());
 
       std::pair<KeyType, std::vector<EnumType> > grouping = std::make_pair(key, values);
 

data/ext/libsass/src/sass_values.cpp

@@ -1,3 +1,4 @@
+#include "sass.hpp"
 #include <cstdlib>
 #include <cstring>
 #include "util.hpp"
@@ -276,7 +277,8 @@ extern "C" {
   {
     Memory_Manager mem;
     Value* val = sass_value_to_ast_node(mem, v);
-    std::string str(val->to_string(compressed, precision));
+    Sass_Inspect_Options options(compressed ? COMPRESSED : NESTED, precision);
+    std::string str(val->to_string(options));
     return sass_make_qstring(str.c_str());
   }
 
@@ -290,42 +292,43 @@ extern "C" {
 
       Value* lhs = sass_value_to_ast_node(mem, a);
       Value* rhs = sass_value_to_ast_node(mem, b);
+      struct Sass_Inspect_Options options(NESTED, 5);
 
       // see if it's a relational expression
       switch(op) {
         case Sass_OP::EQ:  return sass_make_boolean(Eval::eq(lhs, rhs));
         case Sass_OP::NEQ: return sass_make_boolean(!Eval::eq(lhs, rhs));
-        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(lhs, rhs) && !Eval::eq(lhs, rhs));
-        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(lhs, rhs));
-        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(lhs, rhs));
-        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(lhs, rhs) || Eval::eq(lhs, rhs));
+        case Sass_OP::GT:  return sass_make_boolean(!Eval::lt(lhs, rhs, "gt") && !Eval::eq(lhs, rhs));
+        case Sass_OP::GTE: return sass_make_boolean(!Eval::lt(lhs, rhs, "gte"));
+        case Sass_OP::LT:  return sass_make_boolean(Eval::lt(lhs, rhs, "lt"));
+        case Sass_OP::LTE: return sass_make_boolean(Eval::lt(lhs, rhs, "lte") || Eval::eq(lhs, rhs));
         default:           break;
       }
 
       if (sass_value_is_number(a) && sass_value_is_number(b)) {
         const Number* l_n = dynamic_cast<const Number*>(lhs);
         const Number* r_n = dynamic_cast<const Number*>(rhs);
-        rv = Eval::op_numbers(mem, op, *l_n, *r_n);
+        rv = Eval::op_numbers(mem, op, *l_n, *r_n, options);
       }
       else if (sass_value_is_number(a) && sass_value_is_color(a)) {
         const Number* l_n = dynamic_cast<const Number*>(lhs);
         const Color* r_c = dynamic_cast<const Color*>(rhs);
-        rv = Eval::op_number_color(mem, op, *l_n, *r_c);
+        rv = Eval::op_number_color(mem, op, *l_n, *r_c, options);
       }
       else if (sass_value_is_color(a) && sass_value_is_number(b)) {
         const Color* l_c = dynamic_cast<const Color*>(lhs);
         const Number* r_n = dynamic_cast<const Number*>(rhs);
-        rv = Eval::op_color_number(mem, op, *l_c, *r_n);
+        rv = Eval::op_color_number(mem, op, *l_c, *r_n, options);
       }
       else if (sass_value_is_color(a) && sass_value_is_color(b)) {
         const Color* l_c = dynamic_cast<const Color*>(lhs);
         const Color* r_c = dynamic_cast<const Color*>(rhs);
-        rv = Eval::op_colors(mem, op, *l_c, *r_c);
+        rv = Eval::op_colors(mem, op, *l_c, *r_c, options);
       }
       else /* convert other stuff to string and apply operation */ {
         Value* l_v = dynamic_cast<Value*>(lhs);
         Value* r_v = dynamic_cast<Value*>(rhs);
-        rv = Eval::op_strings(mem, op, *l_v, *r_v);
+        rv = Eval::op_strings(mem, op, *l_v, *r_v, options);
       }
 
       // ToDo: maybe we should should return null value?