sassc 0.0.9 → 0.0.10

data/ext/libsass/sass_util.hpp

@@ -1,24 +1,23 @@
+#ifndef SASS_SASS_UTIL_H
+#define SASS_SASS_UTIL_H
+
 #include <deque>
 #include <iostream>
 
-#ifndef SASS_AST
 #include "ast.hpp"
-#endif
-
 #include "node.hpp"
 #include "debug.hpp"
 
-
 namespace Sass {
 
-  
+
   using namespace std;
 
 
   /*
    This is for ports of functions in the Sass:Util module.
    */
-  
+
 
   /*
     # Return a Node collection of all possible paths through the given Node collection of Node collections.
@@ -34,8 +33,8 @@ namespace Sass {
     #     #  [2, 4, 5]]
   */
   Node paths(const Node& arrs, Context& ctx);
-  
-  
+
+
   /*
   This class is a default implementation of a Node comparator that can be passed to the lcs function below.
   It uses operator== for equality comparision. It then returns one if the Nodes are equal.
@@ -54,13 +53,13 @@ namespace Sass {
     }
   };
 
-  
+
   typedef vector<vector<int> > LCSTable;
-  
-  
+
+
   /*
   This is the equivalent of ruby's Sass::Util.lcs_backtrace.
-  
+
   # Computes a single longest common subsequence for arrays x and y.
   # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS
   */
@@ -72,7 +71,7 @@ namespace Sass {
       DEBUG_PRINTLN(LCS, "RETURNING EMPTY")
       return Node::createCollection();
     }
-    
+
     NodeDeque& xChildren = *(x.collection());
     NodeDeque& yChildren = *(y.collection());
 
@@ -83,20 +82,20 @@ namespace Sass {
       result.collection()->push_back(compareOut);
       return result;
     }
-    
+
     if (c[i][j - 1] > c[i - 1][j]) {
       DEBUG_PRINTLN(LCS, "RETURNING AFTER TABLE COMPARE")
       return lcs_backtrace(c, x, y, i, j - 1, comparator);
     }
-    
+
     DEBUG_PRINTLN(LCS, "FINAL RETURN")
     return lcs_backtrace(c, x, y, i - 1, j, comparator);
   }
-  
+
 
   /*
   This is the equivalent of ruby's Sass::Util.lcs_table.
-  
+
   # Calculates the memoization table for the Least Common Subsequence algorithm.
   # Algorithm from http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS
   */
@@ -108,7 +107,7 @@ namespace Sass {
     NodeDeque& yChildren = *(y.collection());
 
     LCSTable c(xChildren.size(), vector<int>(yChildren.size()));
-    
+
     // These shouldn't be necessary since the vector will be initialized to 0 already.
     // x.size.times {|i| c[i][0] = 0}
     // y.size.times {|j| c[0][j] = 0}
@@ -131,7 +130,7 @@ namespace Sass {
 
   /*
   This is the equivalent of ruby's Sass::Util.lcs.
-  
+
   # Computes a single longest common subsequence for `x` and `y`.
   # If there are more than one longest common subsequences,
   # the one returned is that which starts first in `x`.
@@ -150,14 +149,14 @@ namespace Sass {
     Node newX = Node::createCollection();
     newX.collection()->push_back(Node::createNil());
     newX.plus(x);
-    
+
     Node newY = Node::createCollection();
     newY.collection()->push_back(Node::createNil());
     newY.plus(y);
-    
+
     LCSTable table;
     lcs_table(newX, newY, comparator, table);
-    
+
     return lcs_backtrace(table, newX, newY, static_cast<int>(newX.collection()->size()) - 1, static_cast<int>(newY.collection()->size()) - 1, comparator);
   }
 
@@ -167,7 +166,7 @@ namespace Sass {
   Sass::Util.flatten requires the number of levels to flatten, while
   [].flatten doesn't and will flatten the entire array. This function
   supports both.
-  
+
   # Flattens the first `n` nested arrays. If n == -1, all arrays will be flattened
   #
   # @param arr [NodeCollection] The array to flatten
@@ -189,10 +188,10 @@ namespace Sass {
   # @return [Array<[Object, Array]>] An array of pairs.
 
   TODO: update @param and @return once I know what those are.
-  
+
   The following is the modified version of the ruby code that was more portable to C++. You
   should be able to drop it into ruby 3.2.19 and get the same results from ruby sass.
-   
+
     def group_by_to_a(enum, &block)
       order = {}
 
@@ -230,7 +229,7 @@ namespace Sass {
 
     for (typename 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()) {
@@ -244,7 +243,7 @@ namespace Sass {
         collection.push_back(e);
       }
     }
-    
+
     for (unsigned int index = 0; index < order.size(); index++) {
       KeyType& key = order.at(index);
       vector<EnumType>& values = grouped.at(key);
@@ -257,3 +256,5 @@ namespace Sass {
 
 
 }
+
+#endif

data/ext/libsass/sass_values.cpp

@@ -6,10 +6,12 @@
 
 #include <cstdlib>
 #include <cstring>
+#include "util.hpp"
 #include "sass_values.h"
 
 extern "C" {
   using namespace std;
+  using namespace Sass;
 
   struct Sass_Unknown {
     enum Sass_Tag tag;
@@ -164,7 +166,7 @@ extern "C" {
     if (v == 0) return 0;
     v->number.tag = SASS_NUMBER;
     v->number.value = val;
-    v->number.unit = strdup(unit);
+    v->number.unit = unit ? sass_strdup(unit) : 0;
     if (v->number.unit == 0) { free(v); return 0; }
     return v;
   }
@@ -186,7 +188,7 @@ extern "C" {
     Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->string.tag = SASS_STRING;
-    v->string.value = strdup(val);
+    v->string.value = val ? sass_strdup(val) : 0;
     if (v->string.value == 0) { free(v); return 0; }
     return v;
   }
@@ -227,7 +229,7 @@ extern "C" {
     Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->error.tag = SASS_ERROR;
-    v->error.message = strdup(msg);
+    v->error.message = msg ? sass_strdup(msg) : 0;
     if (v->error.message == 0) { free(v); return 0; }
     return v;
   }
@@ -237,7 +239,7 @@ extern "C" {
     Sass_Value* v = (Sass_Value*) calloc(1, sizeof(Sass_Value));
     if (v == 0) return 0;
     v->warning.tag = SASS_WARNING;
-    v->warning.message = strdup(msg);
+    v->warning.message = msg ? sass_strdup(msg) : 0;
     if (v->warning.message == 0) { free(v); return 0; }
     return v;
   }

data/ext/libsass/sass_values.h

@@ -1,5 +1,5 @@
-#ifndef SASS_C_VALUES
-#define SASS_C_VALUES
+#ifndef SASS_C_VALUES_H
+#define SASS_C_VALUES_H
 
 #include <stddef.h>
 #include <stdbool.h>
@@ -83,7 +83,7 @@ ADDAPI void ADDCALL sass_list_set_value (union Sass_Value* v, size_t i, union Sa
 
 // Getter for the number of items in map
 ADDAPI size_t ADDCALL sass_map_get_length (const union Sass_Value* v);
-// Getters and setters for Sass_List keys and values
+// Getters and setters for Sass_Map keys and values
 ADDAPI union Sass_Value* ADDCALL sass_map_get_key (const union Sass_Value* v, size_t i);
 ADDAPI void ADDCALL sass_map_set_key (union Sass_Value* v, size_t i, union Sass_Value*);
 ADDAPI union Sass_Value* ADDCALL sass_map_get_value (const union Sass_Value* v, size_t i);

data/ext/libsass/script/ci-build-libsass

@@ -30,13 +30,18 @@ else
   MAKE_TARGET="shared"
 fi
 
-MAKE_OPTS="$MAKE_OPTS -j3 V=1"
+if [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
+  MAKE_OPTS="$MAKE_OPTS -j1 V=1"
+else
+  MAKE_OPTS="$MAKE_OPTS -j3 V=1"
+fi
 
 if [ "x$AUTOTOOLS" == "xyes" ]; then
 
   echo -en 'travis_fold:start:configure\r'
   autoreconf --force --install
   ./configure --enable-tests $COVERAGE_OPT \
+    --prefix=build \
     --disable-silent-rules \
     --with-sassc-dir=$SASS_SASSC_PATH \
     --with-sass-spec-dir=$SASS_SPEC_PATH \
@@ -44,8 +49,15 @@ if [ "x$AUTOTOOLS" == "xyes" ]; then
     ${SHARED_OPT}
   echo -en 'travis_fold:end:configure\r'
 
+  make clean
+
   make $MAKE_OPTS install
 
+  if [ -d build/lib ]; then
+    mkdir -p lib
+    cp -a build/lib/* lib/
+  fi
+
 else
 
   make clean

data/ext/libsass/script/ci-report-coverage

@@ -9,7 +9,8 @@ if [ "x$COVERAGE" = "xyes" ]; then
                              --exclude cencode.c --exclude b64
                              --exclude utf8 --exclude utf8_string.hpp
                              --exclude utf8.h --exclude utf8_string.cpp
-                             --exclude test"
+                             --exclude sass2scss.h --exclude sass2scss.cpp
+                             --exclude test --exclude posix"
   # debug via gcovr
   gcov -v
   gcovr -r .

data/ext/libsass/source_map.cpp

@@ -1,18 +1,19 @@
-#include "source_map.hpp"
-#include "json.hpp"
-
-#ifndef SASS_CONTEXT
-#include "context.hpp"
-#endif
-
 #include <string>
 #include <sstream>
+#include <iostream>
 #include <cstddef>
 #include <iomanip>
 
+#include "ast.hpp"
+#include "json.hpp"
+#include "context.hpp"
+#include "position.hpp"
+#include "source_map.hpp"
+
 namespace Sass {
   using std::ptrdiff_t;
-  SourceMap::SourceMap(const string& file) : current_position(Position(1, 1)), file(file) { }
+  SourceMap::SourceMap() : current_position(0, 0, 0), file("stdin") { }
+  SourceMap::SourceMap(const string& file) : current_position(0, 0, 0), file(file) { }
 
   string SourceMap::generate_source_map(Context &ctx) {
 
@@ -20,10 +21,16 @@ namespace Sass {
     const vector<string> includes = ctx.include_links;
     const vector<const char*> sources = ctx.sources;
 
-    JsonNode *json_srcmap = json_mkobject();
+    JsonNode* json_srcmap = json_mkobject();
 
     json_append_member(json_srcmap, "version", json_mknumber(3));
 
+    // pass-through sourceRoot option
+    if (!ctx.source_map_root.empty()) {
+      JsonNode* root = json_mkstring(ctx.source_map_root.c_str());
+      json_append_member(json_srcmap, "sourceRoot", root);
+    }
+
     const char *include = file.c_str();
     JsonNode *json_include = json_mkstring(include);
     json_append_member(json_srcmap, "file", json_include);
@@ -71,11 +78,11 @@ namespace Sass {
     size_t previous_original_column = 0;
     size_t previous_original_file = 0;
     for (size_t i = 0; i < mappings.size(); ++i) {
-      const size_t generated_line = mappings[i].generated_position.line - 1;
-      const size_t generated_column = mappings[i].generated_position.column - 1;
-      const size_t original_line = mappings[i].original_position.line - 1;
-      const size_t original_column = mappings[i].original_position.column - 1;
-      const size_t original_file = mappings[i].original_position.file - 1;
+      const size_t generated_line = mappings[i].generated_position.line;
+      const size_t generated_column = mappings[i].generated_position.column;
+      const size_t original_line = mappings[i].original_position.line;
+      const size_t original_column = mappings[i].original_position.column;
+      const size_t original_file = mappings[i].original_position.file;
 
       if (generated_line != previous_generated_line) {
         previous_generated_column = 0;
@@ -105,29 +112,73 @@ namespace Sass {
     return result;
   }
 
-  void SourceMap::remove_line()
+  void SourceMap::prepend(const OutputBuffer& out)
   {
-    // prevent removing non existing lines
-    if (current_position.line > 1) {
-      current_position.line -= 1;
-      current_position.column = 1;
+    Offset size(out.smap.current_position);
+    for (Mapping mapping : out.smap.mappings) {
+      if (mapping.generated_position.line > size.line) {
+        throw(runtime_error("prepend sourcemap has illegal line"));
+      }
+      if (mapping.generated_position.line == size.line) {
+        if (mapping.generated_position.column > size.column) {
+          throw(runtime_error("prepend sourcemap has illegal column"));
+        }
+      }
     }
+    // will adjust the offset
+    prepend(Offset(out.buffer));
+    // now add the new mappings
+    VECTOR_UNSHIFT(mappings, out.smap.mappings);
   }
 
-  void SourceMap::update_column(const string& str)
+  void SourceMap::append(const OutputBuffer& out)
   {
-    const ptrdiff_t new_line_count = std::count(str.begin(), str.end(), '\n');
-    current_position.line += new_line_count;
-    if (new_line_count > 0) {
-      current_position.column = str.size() - str.find_last_of('\n');
-    } else {
-      current_position.column += str.size();
+    append(Offset(out.buffer));
+  }
+
+  void SourceMap::prepend(const Offset& offset)
+  {
+    if (offset.line != 0 || offset.column != 0) {
+      for (Mapping& mapping : mappings) {
+        // move stuff on the first old line
+        if (mapping.generated_position.line == 0) {
+          mapping.generated_position.column += offset.column;
+        }
+        // make place for the new lines
+        mapping.generated_position.line += offset.line;
+      }
+    }
+    if (current_position.line == 0) {
+      current_position.column += offset.column;
     }
+    current_position.line += offset.line;
   }
 
-  void SourceMap::add_mapping(AST_Node* node)
+  void SourceMap::append(const Offset& offset)
   {
-    mappings.push_back(Mapping(node->position(), current_position));
+    current_position += offset;
+  }
+
+  void SourceMap::add_open_mapping(AST_Node* node)
+  {
+    mappings.push_back(Mapping(node->pstate(), current_position));
+  }
+
+  void SourceMap::add_close_mapping(AST_Node* node)
+  {
+    mappings.push_back(Mapping(node->pstate() + node->pstate().offset, current_position));
+  }
+
+  ParserState SourceMap::remap(const ParserState& pstate) {
+    for (size_t i = 0; i < mappings.size(); ++i) {
+      if (
+        mappings[i].generated_position.file == pstate.file &&
+        mappings[i].generated_position.line == pstate.line &&
+        mappings[i].generated_position.column == pstate.column
+      ) return ParserState(pstate.path, mappings[i].original_position, pstate.offset);
+    }
+    return ParserState(pstate.path, Position(-1, -1, -1), Offset(0, 0));
+
   }
 
 }

data/ext/libsass/source_map.hpp

@@ -1,37 +1,41 @@
-#define SASS_SOURCE_MAP
+#ifndef SASS_SOURCE_MAP_H
+#define SASS_SOURCE_MAP_H
 
 #include <vector>
 
-#ifndef SASS_MAPPING
-#include "mapping.hpp"
-#endif
-
-#ifndef SASS_AST
-#include "ast.hpp"
-#endif
-
-#ifndef SASSS_BASE64VLQ
+#include "ast_fwd_decl.hpp"
 #include "base64vlq.hpp"
-#endif
-
+#include "position.hpp"
+#include "mapping.hpp"
 
+#define VECTOR_PUSH(vec, ins) vec.insert(vec.end(), ins.begin(), ins.end())
+#define VECTOR_UNSHIFT(vec, ins) vec.insert(vec.begin(), ins.begin(), ins.end())
 
 namespace Sass {
   using std::vector;
 
-  struct Context;
+  class Context;
+  class OutputBuffer;
 
   class SourceMap {
 
   public:
     vector<size_t> source_index;
+    SourceMap();
     SourceMap(const string& file);
 
-    void remove_line();
-    void update_column(const string& str);
-    void add_mapping(AST_Node* node);
+    void setFile(const string& str) {
+      file = str;
+    }
+    void append(const Offset& offset);
+    void prepend(const Offset& offset);
+    void append(const OutputBuffer& out);
+    void prepend(const OutputBuffer& out);
+    void add_open_mapping(AST_Node* node);
+    void add_close_mapping(AST_Node* node);
 
     string generate_source_map(Context &ctx);
+    ParserState remap(const ParserState& pstate);
 
   private:
 
@@ -39,8 +43,23 @@ namespace Sass {
 
     vector<Mapping> mappings;
     Position current_position;
+public:
     string file;
+private:
     Base64VLQ base64vlq;
   };
 
+  class OutputBuffer {
+    public:
+      OutputBuffer(void)
+      : buffer(""),
+        smap()
+      { }
+    public:
+      string buffer;
+      SourceMap smap;
+  };
+
 }
+
+#endif