sassc 2.2.1 → 2.3.0

data/ext/libsass/src/remove_placeholders.cpp

@@ -1,11 +1,9 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+#include "ast.hpp"
 
 #include "remove_placeholders.hpp"
-#include "context.hpp"
-#include "inspect.hpp"
-#include <iostream>
 
 namespace Sass {
 
@@ -13,75 +11,76 @@ namespace Sass {
     { }
 
     void Remove_Placeholders::operator()(Block* b) {
-        for (size_t i = 0, L = b->length(); i < L; ++i) {
-            Statement* st = b->at(i);
-            st->perform(this);
-        }
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        if (b->get(i)) b->get(i)->perform(this);
+      }
     }
 
-    Selector_List* Remove_Placeholders::remove_placeholders(Selector_List* sl)
+    void Remove_Placeholders::remove_placeholders(SimpleSelector* simple)
     {
-      Selector_List* new_sl = SASS_MEMORY_NEW(Selector_List, sl->pstate());
-
-      for (size_t i = 0, L = sl->length(); i < L; ++i) {
-          if (!sl->at(i)->contains_placeholder()) {
-              new_sl->append(sl->at(i));
-          }
+      if (Pseudo_Selector * pseudo = simple->getPseudoSelector()) {
+        if (pseudo->selector()) remove_placeholders(pseudo->selector());
       }
-
-      return new_sl;
-
     }
 
+    void Remove_Placeholders::remove_placeholders(CompoundSelector* compound)
+    {
+      for (size_t i = 0, L = compound->length(); i < L; ++i) {
+        if (compound->get(i)) remove_placeholders(compound->get(i));
+      }
+      listEraseItemIf(compound->elements(), listIsEmpty<SimpleSelector>);
+    }
 
-    void Remove_Placeholders::operator()(Ruleset* r) {
-        // Create a new selector group without placeholders
-        Selector_List_Obj sl = Cast<Selector_List>(r->selector());
-
-        if (sl) {
-          // Set the new placeholder selector list
-          r->selector(remove_placeholders(sl));
-          // Remove placeholders in wrapped selectors
-          for (Complex_Selector_Obj cs : sl->elements()) {
-            while (cs) {
-              if (cs->head()) {
-                for (Simple_Selector_Obj& ss : cs->head()->elements()) {
-                  if (Wrapped_Selector* ws = Cast<Wrapped_Selector>(ss)) {
-                    if (Selector_List* wsl = Cast<Selector_List>(ws->selector())) {
-                      Selector_List* clean = remove_placeholders(wsl);
-                      // also clean superflous parent selectors
-                      // probably not really the correct place
-                      clean->remove_parent_selectors();
-                      ws->selector(clean);
-                    }
-                  }
-                }
-              }
-              cs = cs->tail();
-            }
+    void Remove_Placeholders::remove_placeholders(ComplexSelector* complex)
+    {
+      if (complex->has_placeholder()) {
+        complex->clear(); // remove all
+      }
+      else {
+        for (size_t i = 0, L = complex->length(); i < L; ++i) {
+          if (CompoundSelector * compound = complex->get(i)->getCompound()) {
+            if (compound) remove_placeholders(compound);
           }
         }
+        listEraseItemIf(complex->elements(), listIsEmpty<SelectorComponent>);
+      }
+    }
 
-        // Iterate into child blocks
-        Block_Obj b = r->block();
+    SelectorList* Remove_Placeholders::remove_placeholders(SelectorList* sl)
+    {
+      for (size_t i = 0, L = sl->length(); i < L; ++i) {
+        if (sl->get(i)) remove_placeholders(sl->get(i));
+      }
+      listEraseItemIf(sl->elements(), listIsEmpty<ComplexSelector>);
+      return sl;
+    }
 
-        for (size_t i = 0, L = b->length(); i < L; ++i) {
-            if (b->at(i)) {
-                Statement_Obj st = b->at(i);
-                st->perform(this);
-            }
-        }
+    void Remove_Placeholders::operator()(CssMediaRule* rule)
+    {
+      if (rule->block()) operator()(rule->block());
     }
 
-    void Remove_Placeholders::operator()(Media_Block* m) {
-        operator()(m->block());
+    void Remove_Placeholders::operator()(Ruleset* r)
+    {
+      if (SelectorListObj sl = r->selector()) {
+        // Set the new placeholder selector list
+        r->selector((remove_placeholders(sl)));
+      }
+      // Iterate into child blocks
+      Block_Obj b = r->block();
+      for (size_t i = 0, L = b->length(); i < L; ++i) {
+        if (b->get(i)) { b->get(i)->perform(this); }
+      }
     }
-    void Remove_Placeholders::operator()(Supports_Block* m) {
-        operator()(m->block());
+
+    void Remove_Placeholders::operator()(Supports_Block* m)
+    {
+      if (m->block()) operator()(m->block());
     }
 
-    void Remove_Placeholders::operator()(Directive* a) {
-        if (a->block()) a->block()->perform(this);
+    void Remove_Placeholders::operator()(Directive* a)
+    {
+      if (a->block()) a->block()->perform(this);
     }
 
 }

data/ext/libsass/src/remove_placeholders.hpp

@@ -1,33 +1,36 @@
 #ifndef SASS_REMOVE_PLACEHOLDERS_H
 #define SASS_REMOVE_PLACEHOLDERS_H
 
-#pragma once
-
-#include "ast.hpp"
+#include "ast_fwd_decl.hpp"
 #include "operation.hpp"
 
 namespace Sass {
 
+  class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
+
+  public:
+
+    SelectorList* remove_placeholders(SelectorList*);
+    void remove_placeholders(SimpleSelector* simple);
+    void remove_placeholders(CompoundSelector* complex);
+    void remove_placeholders(ComplexSelector* complex);
 
-    class Remove_Placeholders : public Operation_CRTP<void, Remove_Placeholders> {
 
-    public:
-      Selector_List* remove_placeholders(Selector_List*);
+  public:
+    Remove_Placeholders();
+    ~Remove_Placeholders() { }
 
-    public:
-        Remove_Placeholders();
-        ~Remove_Placeholders() { }
+    void operator()(Block*);
+    void operator()(Ruleset*);
+    void operator()(CssMediaRule*);
+    void operator()(Supports_Block*);
+    void operator()(Directive*);
 
-        void operator()(Block*);
-        void operator()(Ruleset*);
-        void operator()(Media_Block*);
-        void operator()(Supports_Block*);
-        void operator()(Directive*);
+    // ignore missed types
+    template <typename U>
+    void fallback(U x) {}
 
-      // ignore missed types
-        template <typename U>
-      void fallback(U x) {}
-    };
+  };
 
 }
 

data/ext/libsass/src/sass.hpp

@@ -65,6 +65,7 @@ namespace Sass {
   // 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;
+  const static Sass_Output_Style TO_CSS = SASS_STYLE_TO_CSS;
 
   // helper to aid dreaded MSVC debug mode
   // see implementation for more details

data/ext/libsass/src/sass2scss.cpp

@@ -467,7 +467,7 @@ namespace Sass
 		// right trim input
 		sass = rtrim(sass);
 
-		// get postion of first meaningfull character in string
+		// get position of first meaningfull character in string
 		size_t pos_left = sass.find_first_not_of(SASS2SCSS_FIND_WHITESPACE);
 
 		// special case for final run
@@ -557,7 +557,7 @@ namespace Sass
 				// default to a selector
 				// change back if property found
 				converter.selector = true;
-				// get postion of first whitespace char
+				// get position of first whitespace char
 				size_t pos_wspace = sass.find_first_of(SASS2SCSS_FIND_WHITESPACE, pos_left);
 				// assertion check for valid result
 				if (pos_wspace != std::string::npos)
@@ -580,7 +580,7 @@ namespace Sass
 							// assertion for valid result
 							if (pos_colon != std::string::npos)
 							{
-								// ... after the first word (skip begining colons)
+								// ... after the first word (skip beginning colons)
 								pos_colon = sass.find_first_of(":", pos_colon);
 								// it is a selector if there was no colon found
 								converter.selector = pos_colon == std::string::npos;
@@ -758,7 +758,7 @@ namespace Sass
 				scss += flush(sass, converter);
 			}
 
-			// get postion of last meaningfull char
+			// get position of last meaningfull char
 			size_t pos_right = sass.find_last_not_of(SASS2SCSS_FIND_WHITESPACE);
 
 			// check for invalid result

data/ext/libsass/src/sass_context.cpp

@@ -1,23 +1,10 @@
 // sass.hpp must go before all system headers to get the
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
-
-#include <cstring>
-#include <stdexcept>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "sass.h"
 #include "ast.hpp"
-#include "file.hpp"
-#include "json.hpp"
-#include "util.hpp"
-#include "context.hpp"
-#include "sass_context.hpp"
+
 #include "sass_functions.hpp"
-#include "ast_fwd_decl.hpp"
-#include "error_handling.hpp"
+#include "json.hpp"
 
 #define LFEED "\n"
 
@@ -31,6 +18,24 @@ namespace Sass {
     return json_mkstring(str.c_str());
   }
 
+  static void handle_string_error(Sass_Context* c_ctx, const std::string& msg, int severety)
+  {
+    std::stringstream msg_stream;
+    JsonNode* json_err = json_mkobject();
+    msg_stream << "Internal Error: " << msg << std::endl;
+    json_append_member(json_err, "status", json_mknumber(severety));
+    json_append_member(json_err, "message", json_mkstring(msg.c_str()));
+    json_append_member(json_err, "formatted", json_mkstream(msg_stream));
+    try { c_ctx->error_json = json_stringify(json_err, "  "); }
+    catch (...) {}
+    c_ctx->error_message = sass_copy_string(msg_stream.str());
+    c_ctx->error_text = sass_copy_c_string(msg.c_str());
+    c_ctx->error_status = severety;
+    c_ctx->output_string = 0;
+    c_ctx->source_map_string = 0;
+    json_delete(json_err);
+  }
+
   static int handle_error(Sass_Context* c_ctx) {
     try {
       throw;
@@ -110,96 +115,34 @@ namespace Sass {
       json_append_member(json_err, "message", json_mkstring(e.what()));
       json_append_member(json_err, "formatted", json_mkstream(msg_stream));
       try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
+      catch (...) {} // silently ignore this error?
       c_ctx->error_message = sass_copy_string(msg_stream.str());
       c_ctx->error_text = sass_copy_c_string(e.what());
       c_ctx->error_status = 1;
       c_ctx->error_file = sass_copy_c_string(e.pstate.path);
       c_ctx->error_line = e.pstate.line + 1;
       c_ctx->error_column = e.pstate.column + 1;
-      c_ctx->error_src = e.pstate.src;
+      c_ctx->error_src = sass_copy_c_string(e.pstate.src);
       c_ctx->output_string = 0;
       c_ctx->source_map_string = 0;
       json_delete(json_err);
     }
     catch (std::bad_alloc& ba) {
       std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      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_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string(ba.what());
-      c_ctx->error_status = 2;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      msg_stream << "Unable to allocate memory: " << ba.what();
+      handle_string_error(c_ctx, msg_stream.str(), 2);
     }
     catch (std::exception& e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      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_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string(e.what());
-      c_ctx->error_status = 3;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, e.what(), 3);
     }
     catch (std::string& e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      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_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string(e.c_str());
-      c_ctx->error_status = 4;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, e, 4);
     }
     catch (const char* e) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      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_mkstream(msg_stream));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string(e);
-      c_ctx->error_status = 4;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, e, 4);
     }
     catch (...) {
-      std::stringstream msg_stream;
-      JsonNode* json_err = json_mkobject();
-      msg_stream << "Unknown error occurred" << std::endl;
-      json_append_member(json_err, "status", json_mknumber(5));
-      json_append_member(json_err, "message", json_mkstring("unknown"));
-      try { c_ctx->error_json = json_stringify(json_err, "  "); }
-      catch (...) {}
-      c_ctx->error_message = sass_copy_string(msg_stream.str());
-      c_ctx->error_text = sass_copy_c_string("unknown");
-      c_ctx->error_status = 5;
-      c_ctx->output_string = 0;
-      c_ctx->source_map_string = 0;
-      json_delete(json_err);
+      handle_string_error(c_ctx, "unknown", 5);
     }
     return c_ctx->error_status;
   }
@@ -334,8 +277,8 @@ extern "C" {
       c_ctx->error_message = 0;
       c_ctx->error_status = 0;
       // reset error position
-      c_ctx->error_src = 0;
       c_ctx->error_file = 0;
+      c_ctx->error_src = 0;
       c_ctx->error_line = std::string::npos;
       c_ctx->error_column = std::string::npos;
 
@@ -399,7 +342,9 @@ extern "C" {
 
   Sass_File_Context* ADDCALL sass_make_file_context(const char* input_path)
   {
-    SharedObj::setTaint(true); // needed for static colors
+    #ifdef DEBUG_SHARED_PTR
+    SharedObj::setTaint(true);
+    #endif
     struct Sass_File_Context* ctx = (struct Sass_File_Context*) calloc(1, sizeof(struct Sass_File_Context));
     if (ctx == 0) { std::cerr << "Error allocating memory for file context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_FILE;
@@ -416,6 +361,9 @@ extern "C" {
 
   Sass_Data_Context* ADDCALL sass_make_data_context(char* source_string)
   {
+    #ifdef DEBUG_SHARED_PTR
+    SharedObj::setTaint(true);
+    #endif
     struct Sass_Data_Context* ctx = (struct Sass_Data_Context*) calloc(1, sizeof(struct Sass_Data_Context));
     if (ctx == 0) { std::cerr << "Error allocating memory for data context" << std::endl; return 0; }
     ctx->type = SASS_CONTEXT_DATA;
@@ -451,7 +399,7 @@ extern "C" {
       return data_ctx->error_status;
     try {
       if (data_ctx->source_string == 0) { throw(std::runtime_error("Data context has no source string")); }
-      // empty source string is a valid case, even if not really usefull (different than with file context)
+      // empty source string is a valid case, even if not really useful (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; }
@@ -533,7 +481,7 @@ extern "C" {
   static void sass_clear_options (struct Sass_Options* options)
   {
     if (options == 0) return;
-    // Deallocate custom functions, headers and importes
+    // Deallocate custom functions, headers and imports
     sass_delete_function_list(options->c_functions);
     sass_delete_importer_list(options->c_importers);
     sass_delete_importer_list(options->c_headers);
@@ -594,6 +542,7 @@ extern "C" {
     if (ctx->error_text)        free(ctx->error_text);
     if (ctx->error_json)        free(ctx->error_json);
     if (ctx->error_file)        free(ctx->error_file);
+    if (ctx->error_src)         free(ctx->error_src);
     free_string_array(ctx->included_files);
     // play safe and reset properties
     ctx->output_string = 0;
@@ -602,6 +551,7 @@ extern "C" {
     ctx->error_text = 0;
     ctx->error_json = 0;
     ctx->error_file = 0;
+    ctx->error_src = 0;
     ctx->included_files = 0;
     // debug leaked memory
     #ifdef DEBUG_SHARED_PTR
@@ -656,7 +606,7 @@ extern "C" {
   void ADDCALL sass_file_context_set_options (struct Sass_File_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }
   void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* ctx, struct Sass_Options* opt) { copy_options(ctx, opt); }
 
-  // Getters for Sass_Compiler options (get conected sass context)
+  // Getters for Sass_Compiler options (get connected sass context)
   enum Sass_Compiler_State ADDCALL sass_compiler_get_state(struct Sass_Compiler* compiler) { return compiler->state; }
   struct Sass_Context* ADDCALL sass_compiler_get_context(struct Sass_Compiler* compiler) { return compiler->c_ctx; }
   struct Sass_Options* ADDCALL sass_compiler_get_options(struct Sass_Compiler* compiler) { return compiler->c_ctx; }
@@ -700,9 +650,9 @@ extern "C" {
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_message);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_text);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_file);
+  IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_src);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_line);
   IMPLEMENT_SASS_CONTEXT_GETTER(size_t, error_column);
-  IMPLEMENT_SASS_CONTEXT_GETTER(const char*, error_src);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, output_string);
   IMPLEMENT_SASS_CONTEXT_GETTER(const char*, source_map_string);
   IMPLEMENT_SASS_CONTEXT_GETTER(char**, included_files);
@@ -712,6 +662,7 @@ extern "C" {
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_message);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_text);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_file);
+  IMPLEMENT_SASS_CONTEXT_TAKER(char*, error_src);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, output_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char*, source_map_string);
   IMPLEMENT_SASS_CONTEXT_TAKER(char**, included_files);