sassc 2.0.0 → 2.4.0

data/ext/libsass/docs/implementations.md

@@ -1,56 +0,0 @@
-There are several implementations of `libsass` for a variety of languages. Here are just a few of them. Note, some implementations may or may not be up to date. We have not verified whether they work.
-
-### C
-* [sassc](https://github.com/hcatlin/sassc)
-
-### Crystal
-* [sass.cr](https://github.com/straight-shoota/sass.cr)
-
-### Elixir
-* [sass.ex](https://github.com/scottdavis/sass.ex)
-
-### Go
-* [go-libsass](https://github.com/wellington/go-libsass)
-* [go_sass](https://github.com/suapapa/go_sass)
-* [go-sass](https://github.com/SamWhited/go-sass)
-
-### Lua
-* [lua-sass](https://github.com/craigbarnes/lua-sass)
-
-### .NET
-* [libsass-net](https://github.com/darrenkopp/libsass-net)
-* [NSass](https://github.com/TBAPI-0KA/NSass)
-* [Sass.Net](https://github.com/andyalm/Sass.Net)
-
-### node.js
-* [node-sass](https://github.com/andrew/node-sass)
-
-### Java
-* [libsass-maven-plugin](https://github.com/warmuuh/libsass-maven-plugin)
-* [jsass](https://github.com/bit3/jsass)
-
-### JavaScript
-* [sass.js](https://github.com/medialize/sass.js)
-
-### Perl
-* [CSS::Sass](https://github.com/caldwell/CSS-Sass)
-* [Text::Sass::XS](https://github.com/ysasaki/Text-Sass-XS)
-
-### PHP
-* [sassphp](https://github.com/sensational/sassphp)
-* [php-sass](https://github.com/lesstif/php-sass)
-
-### Python
-* [libsass-python](https://github.com/dahlia/libsass-python)
-* [SassPython](https://github.com/marianoguerra/SassPython)
-* [pylibsass](https://github.com/rsenk330/pylibsass)
-* [python-scss](https://github.com/pistolero/python-scss)
-
-### Ruby
-* [sassruby](https://github.com/hcatlin/sassruby)
-
-### Scala
-* [Sass-Scala](https://github.com/kkung/Sass-Scala)
-
-### Tcl
-* [tclsass](https://github.com/flightaware/tclsass)

data/ext/libsass/docs/plugins.md

@@ -1,47 +0,0 @@
-Plugins are shared object files (.so on *nix and .dll on win) that can be loaded by LibSass on runtime. Currently we only provide a way to load internal/custom functions from plugins. In the future we probably will also add a way to provide custom importers via plugins (needs more refactoring to [support multiple importers with some kind of priority system](https://github.com/sass/libsass/issues/962)).
-
-## plugin.cpp
-
-```C++
-#include <cstring>
-#include <iostream>
-#include <stdint.h>
-#include "sass_values.h"
-
-union Sass_Value* ADDCALL call_fn_foo(const union Sass_Value* s_args, void* cookie)
-{
-  // we actually abuse the void* to store an "int"
-  return sass_make_number((intptr_t)cookie, "px");
-}
-
-extern "C" const char* ADDCALL libsass_get_version() {
-  return libsass_version();
-}
-
-extern "C" Sass_C_Function_List ADDCALL libsass_load_functions()
-{
-  // allocate a custom function caller
-  Sass_C_Function_Callback fn_foo =
-    sass_make_function("foo()", call_fn_foo, (void*)42);
-  // create list of all custom functions
-  Sass_C_Function_List fn_list = sass_make_function_list(1);
-  // put the only function in this plugin to the list
-  sass_function_set_list_entry(fn_list, 0, fn_foo);
-  // return the list
-  return fn_list;
-}
-```
-
-To compile the plugin you need to have LibSass already built as a shared library (to link against it). The commands below expect the shared library in the `lib` sub-directory (`-Llib`). The plugin and the main LibSass process should "consume" the same shared LibSass library on runtime. It will propably also work if they use different LibSass versions. In this case we check if the major versions are compatible (i.e. 3.1.3 and 3.1.1 would be considered compatible).
-
-## Compile with gcc on linux
-
-```bash
-g++ -O2 -shared plugin.cpp -o plugin.so -fPIC -Llib -lsass
-```
-
-## Compile with mingw on windows
-
-```bash
-g++ -O2 -shared plugin.cpp -o plugin.dll -Llib -lsass
-```

data/ext/libsass/docs/setup-environment.md

@@ -1,68 +0,0 @@
-## Requirements
-In order to install and setup your local development environment, there are some prerequisites:
-
-* git
-* gcc/clang/llvm (Linux: build tools, Mac OS X: XCode w/ Command Line Tools)
-* ruby w/ bundler
-
-OS X:
-First you'll need to install XCode which you can now get from the AppStore installed on your mac. After you download that and run it, then run this on the command line:
-
-````
-xcode-select --install
-````
-
-## Cloning the Projects
-
-First, clone the project and then add a line to your `~/.bash_profile` that will let other programs know where the LibSass dev files are.
-
-````
-git clone git@github.com:sass/libsass.git
-cd libsass
-echo "export SASS_LIBSASS_PATH=$(pwd)" >> ~/.bash_profile
-
-````
-
-Then, if you run the "bootstrap" script, it should clone all the other required projects.
-
-````
-./script/bootstrap
-````
-
-You should now have a `sass-spec` and `sassc` folder within the libsass folder. Both of these are clones of their respective git projects. If you want to do a pull request, remember to work in those folders. For instance, if you want to add a test (see other documentation for how to do that), make sure to commit it to your *fork* of the sass-spec github project. Also, whenever you are running tests, make sure to `pull` from the origin! We want to make sure we are testing against the newest libsass, sassc, and sass-spec!
-
-Now, try and see if you can build the project. We do that with the `make` command.
-
-````
-make
-````
-
-At this point, if you get an error, something is most likely wrong with your compiler installation. Yikes. It's hard to cover how to fix this in an article. Feel free to open an issue and we'll try and help! But, remember, before you do that, googling the error message is your friend! Many problems are solved quickly that way.
-
-## Running The Spec Against LibSass
-
-Then, to run the spec against LibSass, just run:
-
-````
-./script/spec
-````
-
-If you get an error about `SASS_LIBSASS_PATH`, you may still need to set a variable pointing to the libsass folder, like this:
-
-````
-export SASS_LIBSASS_PATH=/Users/you/path/libsass
-````
-
-...where the latter part is to the `libsass` directory you've cloned. You can get this path by typing `pwd` in the Terminal
-
-## Running the Spec Against Ruby Sass
-
-Go into the sass-spec folder that should have been cloned earlier with the "bootstrap" command. Run the following.
-
-````
-bundle install
-./sass-spec.rb
-````
-
-Voila! Now you are testing against Sass too!
-

data/ext/libsass/docs/source-map-internals.md

@@ -1,51 +0,0 @@
-This document is mainly intended for developers!
-
-# Documenting some of the source map internals
-
-Since source maps are somewhat a black box to all LibSass maintainers, [I](@mgreter) will try to document my findings with source maps in LibSass, as I come across them. This document will also brievely explain how LibSass parses the source and how it outputs the result.
-
-The main storage for SourceMap mappings is the `mappings` vector:
-
-```
-# in source_map.hpp
-vector<Mapping> mappings
-# in mappings.hpp
-struct Mapping ...
-  Position original_position;
-  Position generated_position;
-```
-
-## Every parsed token has its source associated
-
-LibSass uses a lexical parser. Whenever LibSass finds a token of interest, it creates a specific `AST_Node`, which will hold a reference to the input source with line/column information. `AST_Node` is the base class for all parsed items. They are declared in `ast.hpp` and are used in `parser.hpp`. Here a simple example:
-
-```
-if (lex< custom_property_name >()) {
-  Sass::String* prop = new (ctx.mem) String_Constant(path, source_position, lexed);
-  return new (ctx.mem) Declaration(path, prop->position(), prop, ...);
-}
-```
-
-## How is the `source_position` calculated
-
-This is automatically done with `lex` in `parser.hpp`. Whenever something is lexed, the `source_position` is updated. But be aware that `source_position` points to the begining of the parsed text. If you need a mapping for the position where the parsing ended, you need to add another call to `lex` (to match nothing)!
-
-```
-lex< exactly < empty_str > >();
-end = new (ctx.mem) String_Constant(path, source_position, lexed);
-```
-
-## How are mappings for the output created
-
-So far we have collected all needed data for all tokens in the input stream. We can now use this information to create mappings when we put things into the output stream. Mappings are created via the `add_mappings` method:
-
-```
-# in source_map.hpp
-void add_mapping(AST_Node* node);
-```
-
-This method is called in two places:
-- `Inspect::append_to_buffer`
-- `Output_[Nested|Compressed]::append_to_buffer`
-
-Mappings can only be created for things that have been parsed into a `AST_Node`. Otherwise we do not have the information to create the mappings, which is the reason why LibSass currently only maps the most important tokens in source maps.

data/ext/libsass/docs/trace.md

@@ -1,26 +0,0 @@
-## This is proposed interface in https://github.com/sass/libsass/pull/1288
-
-Additional debugging macros with low overhead are available, `TRACE()` and `TRACEINST()`.
-
-Both macros simulate a string stream, so they can be used like this:
-
-    TRACE() << "Reached.";
-
-produces:
-
-    [LibSass] parse_value parser.cpp:1384 Reached.
-
-`TRACE()`
-   logs function name, source filename, source file name to the standard error and the attached
-   stream to the standard error.
-
-`TRACEINST(obj)`
-   logs object instance address, function name, source filename, source file name to the standard error and the attached stream to the standard error, for example:
-
-    TRACEINST(this) << "String_Constant created " << this;
-
-produces:
-
-    [LibSass] 0x8031ba980:String_Constant ./ast.hpp:1371 String_Constant created (0,"auto")
-
-The macros generate output only of `LibSass_TRACE` is set in the environment.

data/ext/libsass/docs/triage.md

@@ -1,17 +0,0 @@
-This is an article about how to help with LibSass issues. Issue triage is a fancy word for explaining how we deal with incoming issues and make sure that the right problems get worked on. The lifecycle of an issue goes like this:
-
-1. Issue is reported by a user.
-2. If the issue seems like a bug, then the "bug" tag is added.
-3. If the reporting user didn't also create a spec test over at sass/sass-spec, the "needs test" tag is added.
-4. Verify that Ruby Sass *does not* have the same bug. LibSass strives to be an exact replica of how Ruby Sass works. If it's an issue that neither project has solved, please close the ticket with the "not in sass" label.
-5. The smallest possible breaking test is created in sass-spec. Cut away any extra information or non-breaking code until the core issue is made clear.
-6. Again, verify that the expected output matches the latest Ruby Sass release. Do this by using your own tool OR by running ./sass-spec.rb in the spec folder and making sure that your test passes!
-7. Create the test cases in sass-spec with the name spec/LibSass-todo-issues/issue_XXX/input.scss and expected_output.css where the XXX is the issue number here.
-8. Commit that test to sass-spec, making sure to reference the issue in the comment message like "Test to demonstrate sass/LibSass#XXX".
-9. Once the spec test exists, remove the "needs test" tag and replace it with "test written".
-10. A C++ developer will then work on the issue and issue a pull request to fix the issue.
-11. A core member verifies that the fix does actually fix the spec tests.
-12. The fix is merged into the project.
-13. The spec is moved from the LibSass-todo-issues folder into LibSass-closed-issues
-14. The issue is closed
-15. Have a soda pop or enjoyable beverage of your choice

data/ext/libsass/docs/unicode.md

@@ -1,39 +0,0 @@
-LibSass currently expects all input to be utf8 encoded (and outputs only utf8), if you actually have any unicode characters at all. We do not support conversion between encodings, even if you declare it with a `@charset` rule. The text below was originally posted as an [issue](https://github.com/sass/libsass/issues/381) on the LibSass tracker.
-
-### [Declaring character encodings in CSS](http://www.w3.org/International/questions/qa-css-charset.en)
-
-This [explains](http://www.w3.org/International/questions/qa-css-charset.en) how the character encoding of a css file is determined. Since we are only dealing with local files, we never have a HTTP header. So the precedence should be 'charset' rule, byte-order mark (BOM) or auto-detection (finally falling back to system default/UTF-8). This may not sound too hard to implement, but what about import rules? The CSS specs do not forbid the mixing of different encodings! I solved that by converting all files to UTF-8 internally. On writing there is an option to tell the tool what encoding it should be (UTF-8 by default). One can also define if it should write a BOM or not and if it should add the charset declaration.
-
-Since my tool is written in perl, I have a lot of utilities at hand to deal with different unicode charsets. I'm pretty sure that most OSS uses [libiconv](https://www.gnu.org/software/libiconv/) to convert between different encodings. But I have now idea how easy/hard this would be to integrate platform independent (it seems doable).
-
-### Current status on LibSass unicode support
-
-Currently LibSass seems to handle the common UTF-8 case pretty well. I believe it should correctly support all ASCII compatible encodings (like UTF-8 or Latin-1). If all includes use the same encoding, the output should be correct (in the same encoding). It should also handle unicode chars in [selectors, variable names and other identifiers](https://github.com/hcatlin/libsass/issues/244#issuecomment-34681227). This is true for all ASCII compatible encodings. So the main incompatible encodings (I'm aware of) are UTF-16/UTF-32 (which could be converted to UTF-8 with libiconv).
-
-### Current encoding auto detection
-
-LibSass currently reads all kind of BOMs and will error out if it finds something it doesn't know how to handle! It seems that it throws away the optional UTF-8 BOM (if any is found). IMO it would be nice if users could configure that (also if a charset rule should be added to the output).
-
-### What is currently not supported
-
-- Using non ASCII compatible encodings (like UTF-16)
-- Using non ASCII characters in different encodings in different includes
-
-### What is missing to support the above cases
-
-- A way to convert between encodings (like libiconv)
-- Sniffing the charset inside the file (source is available)
-- Handling the conversion on import (and export)
-- Optional: Make output encoding configurable
-- Optional: Add optional/mandatory BOM (configurable)
-
-### Low priority feature
-
-I guess the current implementation should handle more than 99% of all real world use cases.
-A) Unicode characters are still seldomly seen (as they can be written escaped)
-B) It will still work if it's UTF-8 or in any of the most common known western ISO codepages.
-Although I'm not sure how this applies to asian and other "exotic" codepages!
-
-I guess the biggest Problem is to have libiconv (or some other) library as a dependency. Since it contains a lot of rules for the conversions, I see it as the only way to handle this correctly. Once that is sorted out it should be pretty much straight forward to implement the missing pieces (in parser.cpp - Parser::parse should return encoding and add Parser::sniff_charset, then convert the source byte stream to UTF-8).
-
-I hope the statements above all hold true. Unicode is really not the easiest topic to wrap your head around. But since I did all the above recently in Perl, I wanted to document it here. Feel free to extend or criticize.

data/ext/libsass/extconf.rb

@@ -1,6 +0,0 @@
-require 'mkmf'
-# .. more stuff
-#$LIBPATH.push(Config::CONFIG['libdir'])
-$CFLAGS << " #{ENV["CFLAGS"]}"
-$LIBS << " #{ENV["LIBS"]}"
-create_makefile("libsass")

data/ext/libsass/include/sass/version.h.in

@@ -1,12 +0,0 @@
-#ifndef SASS_VERSION_H
-#define SASS_VERSION_H
-
-#ifndef LIBSASS_VERSION
-#define LIBSASS_VERSION "@PACKAGE_VERSION@"
-#endif
-
-#ifndef LIBSASS_LANGUAGE_VERSION
-#define LIBSASS_LANGUAGE_VERSION "3.5"
-#endif
-
-#endif

data/ext/libsass/m4/m4-ax_cxx_compile_stdcxx_11.m4

@@ -1,167 +0,0 @@
-# ============================================================================
-#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
-# ============================================================================
-#
-# SYNOPSIS
-#
-#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
-#
-# DESCRIPTION
-#
-#   Check for baseline language coverage in the compiler for the C++11
-#   standard; if necessary, add switches to CXXFLAGS to enable support.
-#
-#   The first argument, if specified, indicates whether you insist on an
-#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
-#   -std=c++11).  If neither is specified, you get whatever works, with
-#   preference for an extended mode.
-#
-#   The second argument, if specified 'mandatory' or if left unspecified,
-#   indicates that baseline C++11 support is required and that the macro
-#   should error out if no mode with that support is found.  If specified
-#   'optional', then configuration proceeds regardless, after defining
-#   HAVE_CXX11 if and only if a supporting mode is found.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
-#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
-#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
-#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 11
-
-m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [[
-  template <typename T>
-    struct check
-    {
-      static_assert(sizeof(int) <= sizeof(T), "not big enough");
-    };
-
-    struct Base {
-    virtual void f() {}
-    };
-    struct Child : public Base {
-    virtual void f() override {}
-    };
-
-    typedef check<check<bool>> right_angle_brackets;
-
-    int a;
-    decltype(a) b;
-
-    typedef check<int> check_type;
-    check_type c;
-    check_type&& cr = static_cast<check_type&&>(c);
-
-    auto d = a;
-    auto l = [](){};
-    // Prevent Clang error: unused variable 'l' [-Werror,-Wunused-variable]
-    struct use_l { use_l() { l(); } };
-
-    // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
-    // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function because of this
-    namespace test_template_alias_sfinae {
-        struct foo {};
-
-        template<typename T>
-        using member = typename T::member_type;
-
-        template<typename T>
-        void func(...) {}
-
-        template<typename T>
-        void func(member<T>*) {}
-
-        void test();
-
-        void test() {
-            func<foo>(0);
-        }
-    }
-]])
-
-AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
-  m4_if([$1], [], [],
-        [$1], [ext], [],
-        [$1], [noext], [],
-        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
-  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
-        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
-        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
-        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])
-  AC_LANG_PUSH([C++])dnl
-  ac_success=no
-  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
-  ax_cv_cxx_compile_cxx11,
-  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-    [ax_cv_cxx_compile_cxx11=yes],
-    [ax_cv_cxx_compile_cxx11=no])])
-  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
-    ac_success=yes
-  fi
-
-  m4_if([$1], [noext], [], [dnl
-  if test x$ac_success = xno; then
-    for switch in -std=gnu++11 -std=gnu++0x; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-
-  m4_if([$1], [ext], [], [dnl
-  if test x$ac_success = xno; then
-    dnl HP's aCC needs +std=c++11 according to:
-    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
-    for switch in -std=c++11 -std=c++0x +std=c++11; do
-      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
-      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
-                     $cachevar,
-        [ac_save_CXXFLAGS="$CXXFLAGS"
-         CXXFLAGS="$CXXFLAGS $switch"
-         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
-          [eval $cachevar=yes],
-          [eval $cachevar=no])
-         CXXFLAGS="$ac_save_CXXFLAGS"])
-      if eval test x\$$cachevar = xyes; then
-        CXXFLAGS="$CXXFLAGS $switch"
-        ac_success=yes
-        break
-      fi
-    done
-  fi])
-  AC_LANG_POP([C++])
-  if test x$ax_cxx_compile_cxx11_required = xtrue; then
-    if test x$ac_success = xno; then
-      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
-    fi
-  else
-    if test x$ac_success = xno; then
-      HAVE_CXX11=0
-      AC_MSG_NOTICE([No compiler with C++11 support was found])
-    else
-      HAVE_CXX11=1
-      AC_DEFINE(HAVE_CXX11,1,
-                [define if the compiler supports basic C++11 syntax])
-    fi
-
-    AC_SUBST(HAVE_CXX11)
-  fi
-])