sassc 1.11.1 → 1.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2003bd0fdc35ac8281c0f203771b9e88e3554ce6
-  data.tar.gz: 4181ece117d80e29ff8abf55805fc8e7710e3c3f
+  metadata.gz: 4b738b9d16e9e4b192dd5648204b01388b12d1e2
+  data.tar.gz: 83c05efa8d19833ef97ca727bba32441de3ea154
 SHA512:
-  metadata.gz: 44ff8a7c1c903405f2124f670b5277fee9f47bd4f61c5c429524b1812a8c3497fd1f4c0ca6812bc886b4414bdeb70846f3a69aef2d0cfd124c5cc30c2e332773
-  data.tar.gz: cc5690cb269eaa0408ae7c5b6f72aa71b11530357a72b930f3bfcae95ef56df708b97ba1a0c7af6e806802479023e4a306e22ae3758fac656bec84dbb270b494
+  metadata.gz: f6a44d53f4bd75fd8c9ad74051d89d41bbd9b8920715895ec501c3ee1ce5cf7b54bb056623d59b7e52e2c49ad59a27be3486e0d2c087453a4cafb5b16d19e4b4
+  data.tar.gz: 9afe2183443c33e38313d41d43d8072b39bb78057bdd47e75455288311b140604d819e1d7900b301a2712f4752f1944fbc29d226732a3a6458458765ced549d9

data/.travis.yml

@@ -3,8 +3,8 @@ language: ruby
 bundler_args: "--binstubs --standalone --without documentation --path ../bundle"
 script: "bundle exec rake test"
 rvm:
-  - 2.0.0
-  - 2.1.5
   - 2.2.0
+  - 2.3.3
+  - 2.4.0
 notifications:
   email: false

data/README.md

@@ -6,7 +6,7 @@ This gem combines the speed of `libsass`, the [Sass C implementation](https://gi
 
 ### libsass Version
 
-[3.4.1](https://github.com/sass/libsass/releases/tag/3.4.1)
+[3.4.3](https://github.com/sass/libsass/releases/tag/3.4.3)
 
 ## Installation
 
@@ -48,7 +48,8 @@ This gem is maintained by [Ryan Boland](https://ryanboland.com)
 and [awesome contributors](https://github.com/bolandrm/sassc-ruby/graphs/contributors).
 
 ## Changelog
-
+- **1.11.2**
+  - [Update to libsass 3.4.3](https://github.com/sass/sassc-ruby/pull/65)
 - **1.11.1**
   - [Update to libsass 3.4.1](https://github.com/sass/sassc-ruby/pull/61)
 - **1.11.0**

data/ext/libsass/Makefile.conf

@@ -43,8 +43,9 @@ SOURCES = \
 	to_c.cpp \
 	to_value.cpp \
 	source_map.cpp \
+	subset_map.cpp \
 	error_handling.cpp \
-	memory_manager.cpp \
+	memory/SharedPtr.cpp \
 	utf8_string.cpp \
 	base64vlq.cpp
 

data/ext/libsass/appveyor.yml

@@ -3,7 +3,7 @@ os: Visual Studio 2013
 environment:
   CTEST_OUTPUT_ON_FAILURE: 1
   ruby_version: 22-x64
-  TargetPath: sassc/bin/sassc
+  TargetPath: sassc/bin/sassc.exe
   matrix:
   - Compiler: msvc
     Config: Release
@@ -63,14 +63,19 @@ test_script:
           git -C sass-spec checkout -q --force ci-spec-pr-$SPEC_PR
         }
       }
-      ruby sass-spec/sass-spec.rb -V 3.4 --probe-todo --impl libsass -c $env:TargetPath -s sass-spec/spec
-      if(-not($?)) {
-        echo "sass-spec tests failed"
+      $env:TargetPath = Join-Path $pwd.Path $env:TargetPath
+      If (Test-Path "$env:TargetPath") {
+        ruby sass-spec/sass-spec.rb -V 3.4 --probe-todo --impl libsass -c $env:TargetPath -s sass-spec/spec
+        if(-not($?)) {
+          echo "sass-spec tests failed"
+          exit 1
+        }
+      } else {
+        echo "spec runner not found (compile error?)"
         exit 1
       }
       Write-Host "Explicitly testing the case when cwd has Cyrillic characters: " -nonewline
       # See comments in gh-1774 for details.
-      $env:TargetPath =  Join-Path $pwd.Path $env:TargetPath
       cd sass-spec/spec/libsass/Sáss-UŢF8/
       &$env:TargetPath ./input.scss 2>&1>$null
       if(-not($?)) {

data/ext/libsass/docs/dev-ast-memory.md

@@ -0,0 +1,223 @@
+# LibSass smart pointer implementation
+
+LibSass uses smart pointers very similar to `shared_ptr` known
+by Boost or C++11. Implementation is a bit less modular since
+it was not needed. Various compile time debug options are
+available if you need to debug memory life-cycles.
+
+
+## Memory Classes
+
+### SharedObj
+
+Base class for the actual node implementations. This ensures
+that every object has a reference counter and other values.
+
+```c++
+class AST_Node : public SharedObj { ... };
+```
+
+### SharedPtr (base class for SharedImpl)
+
+Base class that holds on to the pointer. The reference counter
+is stored inside the pointer object directly (`SharedObj`).
+
+### SharedImpl (inherits from SharedPtr)
+
+This is the main base class for objects you use in your code. It
+will make sure that the memory it points at will be deleted once
+all copies to the same object/memory go out of scope.
+
+```c++
+Class* pointer = new Class(...);
+SharedImpl<Class> obj(pointer);
+```
+
+To spare the developer of typing the templated class every time,
+we created typedefs for each available AST Node specialization.
+
+```c++
+typedef SharedImpl<Number> Number_Obj;
+Number_Obj number = SASS_MEMORY_NEW(...);
+```
+
+
+## Memory life-cycles
+
+### Pointer pickups
+
+I often use the terminology of "pickup". This means the moment when
+a raw pointer not under any control is assigned to a reference counted
+object (`XYZ_Obj = XYZ_Ptr`). From that point on memory will be
+automatically released once the object goes out of scope (but only
+if the reference counter reaches zero). Main point beeing, you don't
+have to worry about memory management yourself.
+
+### Object detach
+
+Sometimes we can't return reference counted objects directly (see
+invalid covariant return types problems below). But we often still
+need to use reference objects inside a function to avoid leaks when
+something throws. For this you can use `detach`, which basically
+detaches the pointer memory from the reference counted object. So
+when the reference counted object goes out of scope, it will not
+free the attached memory. You are now again in charge of freeing
+the memory (just assign it to a reference counted object again).
+
+
+## Circular references
+
+Reference counted memory implementations are prone to circular references.
+This can be addressed by using a multi generation garbage collector. But
+for our use-case that seems overkill. There is no way so far for users
+(sass code) to create circular references. Therefore we can code around
+this possible issue. But developers should be aware of this limitation.
+
+There are AFAIR two places where circular references could happen. One is
+the `sources` member on every `Selector`. The other one can happen in the
+extend code (Node handling). The easy way to avoid this is to only assign
+complete object clones to these members. If you know the objects lifetime
+is longer than the reference you create, you can also just store the raw
+pointer. Once needed this could be solved with weak pointers.
+
+
+## Addressing the invalid covariant return types problems
+
+If you are not familiar with the mentioned problem, you may want
+to read up on covariant return types and virtual functions, i.e.
+
+- http://stackoverflow.com/questions/6924754/return-type-covariance-with-smart-pointers
+- http://stackoverflow.com/questions/196733/how-can-i-use-covariant-return-types-with-smart-pointers
+- http://stackoverflow.com/questions/2687790/how-to-accomplish-covariant-return-types-when-returning-a-shared-ptr
+
+We hit this issue at least with the CRTP visitor pattern (eval, expand,
+listize and so forth). This means we cannot return reference counted
+objects directly. We are forced to return raw pointers or we would need
+to have a lot of explicit and expensive upcasts by callers/consumers.
+
+### Simple functions that allocate new AST Nodes
+
+In the parser step we often create new objects and can just return a
+unique pointer (meaning ownership clearly shifts back to the caller).
+The caller/consumer is responsible that the memory is freed.
+
+```c++
+typedef Number* Number_Ptr;
+int parse_integer() {
+  ... // do the parsing
+  return 42;
+}
+Number_Ptr parse_number() {
+  Number_Ptr p_nr = SASS_MEMORY_NEW(...);
+  p_nr->value(parse_integer());
+  return p_nr;
+}
+Number_Obj nr = parse_number();
+```
+
+The above would be the encouraged pattern for such simple cases.
+
+### Allocate new AST Nodes in functions that can throw
+
+There is a major caveat with the previous example, considering this
+more real-life implementation that throws an error. The throw may
+happen deep down in another function. Holding raw pointers that
+we need to free would leak in this case.
+
+```c++
+int parse_integer() {
+  ... // do the parsing
+  if (error) throw(error);
+  return 42;
+}
+```
+
+With this `parse_integer` function the previous example would leak memory.
+I guess it is pretty obvious, as the allocated memory will not be freed,
+as it was never assigned to a SharedObj value. Therefore the above code
+would better be written as:
+
+```c++
+typedef Number* Number_Ptr;
+int parse_integer() {
+  ... // do the parsing
+  if (error) throw(error);
+  return 42;
+}
+// this leaks due to pointer return
+// should return Number_Obj instead
+// though not possible for virtuals!
+Number_Ptr parse_number() {
+  Number_Obj nr = SASS_MEMORY_NEW(...);
+  nr->value(parse_integer()); // throws
+  return &nr; // Ptr from Obj
+}
+Number_Obj nr = parse_number();
+// will now be freed automatically
+```
+
+The example above unfortunately will not work as is, since we return a
+`Number_Ptr` from that function. Therefore the object allocated inside
+the function is already gone when it is picked up again by the caller.
+The easy fix for the given simplified use case would be to change the
+return type of `parse_number` to `Number_Obj`. Indeed we do it exactly
+this way in the parser. But as stated above, this will not work for
+virtual functions due to invalid covariant return types!
+
+### Return managed objects from virtual functions
+
+The easy fix would be to just create a new copy on the heap and return
+that. But this seems like a very inelegant solution to this problem. I
+mean why can't we just tell the object to treat it like a newly allocated
+object? And indeed we can. I've added a `detach` method that will tell
+the object to survive deallocation until the next pickup. This means
+that it will leak if it is not picked up by consumer.
+
+```c++
+typedef Number* Number_Ptr;
+int parse_integer() {
+  ... // do the parsing
+  if (error) throw(error);
+  return 42;
+}
+Number_Ptr parse_number() {
+  Number_Obj nr = SASS_MEMORY_NEW(...);
+  nr->value(parse_integer()); // throws
+  return nr.detach();
+}
+Number_Obj nr = parse_number();
+// will now be freed automatically
+```
+
+
+## Compile time debug options
+
+To enable memory debugging you need to define `DEBUG_SHARED_PTR`.
+This can i.e. be done in `include/sass/base.h`
+
+```c++
+define DEBUG_SHARED_PTR
+```
+
+This will print lost memory on exit to stderr. You can also use
+`setDbg(true)` on sepecific variables to emit reference counter
+increase, decrease and other events.
+
+
+## Why reinvent the wheel when there is `shared_ptr` from C++11
+
+First, implementing a smart pointer class is not really that hard. It
+was indeed also a learning experience for myself. But there are more
+profound advantages:
+
+- Better GCC 4.4 compatibility (which most code still has OOTB)
+- Not thread safe (give us some free performance on some compiler)
+- Beeing able to track memory allocations for debugging purposes
+- Adding additional features if needed (as seen in `detach`)
+- Optional: optimized weak pointer implementation possible
+
+### Thread Safety
+
+As said above, this is not thread safe currently. But we don't need
+this ATM anyway. And I guess we probably never will share AST Nodes
+across different threads.

data/ext/libsass/include/sass/base.h

@@ -1,6 +1,8 @@
 #ifndef SASS_BASE_H
 #define SASS_BASE_H
 
+// #define DEBUG_SHARED_PTR
+
 #ifdef _MSC_VER
   #pragma warning(disable : 4503)
   #ifndef _SCL_SECURE_NO_WARNINGS

data/ext/libsass/script/bootstrap

@@ -2,9 +2,12 @@
 
 script/branding
 
-if [ ! -d "sass-spec" ]; then
-  git clone https://github.com/sass/sass-spec.git
+: ${SASS_SPEC_PATH:="sass-spec"}
+: ${SASS_SASSC_PATH:="sassc" }
+
+if [ ! -d $SASS_SPEC_PATH ]; then
+  git clone https://github.com/sass/sass-spec.git $SASS_SPEC_PATH
 fi
-if [ ! -d "sassc" ]; then
-  git clone https://github.com/sass/sassc.git
+if [ ! -d $SASS_SASSC_PATH ]; then
+  git clone https://github.com/sass/sassc.git $SASS_SASSC_PATH
 fi

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

@@ -120,10 +120,10 @@ then
     echo "Fetching Sass Spec PR $SPEC_PR"
     git -C sass-spec fetch -u origin pull/$SPEC_PR/head:ci-spec-pr-$SPEC_PR
     git -C sass-spec checkout --force ci-spec-pr-$SPEC_PR
-    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
+    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
   else
-    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
+    LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
   fi
 else
-  LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_build
+  LD_LIBRARY_PATH="$PREFIX/lib/" make $MAKE_OPTS test_probe
 fi

data/ext/libsass/script/ci-install-compiler

@@ -2,3 +2,5 @@
 
 gem install minitest
 gem install minitap
+
+pip install --user 'requests[security]'

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

@@ -3,7 +3,8 @@
 if [ "x$COVERAGE" = "xyes" ]; then
 
   # exclude some directories from profiling (.libs is from autotools)
-  export EXCLUDE_COVERAGE="--exclude src/sassc
+  export EXCLUDE_COVERAGE="--exclude plugins
+                           --exclude sassc/sassc.c
                            --exclude src/sass-spec
                            --exclude src/.libs
                            --exclude src/debug.hpp

data/ext/libsass/script/test-leaks.pl

@@ -0,0 +1,103 @@
+#!/usr/bin/perl
+############################################################
+# this perl script is meant for developers only!
+# it will run all spec-tests (without verifying the
+# results) via valgrind to detect possible leaks.
+# expect that it takes 1h or more to finish!
+############################################################
+# Prerequisite install: `cpan Parallel::Runner`
+# You may also need to install `cpan File::Find`
+# You may also need to install `cpan IPC::Run3`
+############################################################
+# usage: `perl test-leaks.pl [threads]`
+# example: `time perl test-leaks.pl 4`
+############################################################
+# leaks will be reported in "mem-leaks.log"
+############################################################
+
+use strict;
+use warnings;
+
+############################################################
+# configurations (you may adjust)
+############################################################
+
+# number of threads to use
+my $threads = $ARGV[0] || 8;
+
+# the github repositories to checkout
+# if you need other branch, clone manually!
+my $sassc = "https://www.github.com/sass/sassc";
+my $specs = "https://www.github.com/sass/sass-spec";
+
+############################################################
+# load modules
+############################################################
+
+use IPC::Run3;
+use IO::Handle;
+use Fcntl qw(:flock);
+use File::Find::Rule;
+use Parallel::Runner;
+use List::Util qw(shuffle);
+
+############################################################
+# check prerequisites
+############################################################
+
+unless (-d "../sassc") {
+  warn "sassc folder not found\n";
+  warn "trying to checkout via git\n";
+  system("git", "clone", $sassc, "../sassc");
+  die "git command did not exit gracefully" if $?;
+}
+
+unless (-d "../sass-spec") {
+  warn "sass-spec folder not found\n";
+  warn "trying to checkout via git\n";
+  system("git", "clone", $specs, "../sass-spec");
+  die "git command did not exit gracefully" if $?;
+}
+
+unless (-f "../sassc/bin/sassc") {
+  warn "sassc executable not found\n";
+  warn "trying to compile via make\n";
+  system("make", "-C", "../sassc", "-j", $threads);
+  die "make command did not exit gracefully" if $?;
+}
+
+############################################################
+# main runner code
+############################################################
+
+my $root = "../sass-spec/spec";
+my @files = File::Find::Rule->file()
+            ->name('input.scss')->in($root);
+
+open(my $leaks, ">", "mem-leaks.log");
+die "Cannot open log" unless $leaks;
+my $runner = Parallel::Runner->new($threads);
+die "Cannot start runner" unless $runner;
+
+print "##########################\n";
+print "Testing $#files spec files\n";
+print "##########################\n";
+
+foreach my $file (shuffle @files) {
+  $runner->run(sub {
+    $| = 1; select STDOUT;
+    my $cmd = sprintf('../sassc/bin/sassc %s', $file);
+    my $check = sprintf('valgrind --leak-check=yes %s', $cmd);
+    run3($check, undef, \ my $out, \ my $err);
+    if ($err =~ m/in use at exit: 0 bytes in 0 blocks/) {
+      print "."; # print success indicator
+    } else {
+      print "F"; # print error indicator
+      flock($leaks, LOCK_EX) or die "Cannot lock log";
+      $leaks->printflush("#" x 80, "\n", $err, "\n");
+      flock($leaks, LOCK_UN) or die "Cannot unlock log";
+    }
+  });
+}
+
+$runner->finish;