sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/docs/build-with-makefiles.md

@@ -1,68 +0,0 @@
-### Get the sources
-```bash
-# using git is preferred
-git clone https://github.com/sass/libsass.git
-# only needed for sassc and/or testsuite
-git clone https://github.com/sass/sassc.git libsass/sassc
-git clone https://github.com/sass/sass-spec.git libsass/sass-spec
-```
-
-### Decide for static or shared library
-
-`libsass` can be built and linked as a `static` or as a `shared` library. The default is `static`. To change it you can set the `BUILD` environment variable:
-
-```bash
-export BUILD="shared"
-```
-
-Alternatively you can also define it directly when calling make:
-
-```bash
-BUILD="shared" make ...
-```
-
-### Compile the library
-```bash
-make -C libsass -j5
-```
-
-### Results can be found in
-```bash
-$ ls libsass/lib
-libsass.a libsass.so
-```
-
-### Install onto the system
-
-We recommend to use [autotools to install](build-with-autotools.md) libsass onto the
-system, since that brings all the benefits of using libtools as the main install method.
-If you still want to install libsass via the makefile, you need to make sure that gnu
-`install` utility (or compatible) is installed on your system.
-```bash
-yum install coreutils # RedHat Linux
-emerge -a coreutils # Gentoo Linux
-pkgin install coreutils # SmartOS
-```
-
-You can set the install location by setting `PREFIX`
-```bash
-PREFIX="/opt/local" make install
-```
-
-
-### Compling sassc
-
-```bash
-# Let build know library location
-export SASS_LIBSASS_PATH="`pwd`/libsass"
-# Invokes the sassc makefile
-make -C libsass -j5 sassc
-```
-
-### Run the spec test-suite
-
-```bash
-# needs ruby available
-# also gem install minitest
-make -C libsass -j5 test_build
-```

data/ext/libsass/docs/build-with-mingw.md

@@ -1,107 +0,0 @@
-## Building LibSass with MingGW (makefiles)
-
-First grab the latest [MinGW for windows][1] installer. Once it is installed, you can click on continue or open the Installation Manager via `bin\mingw-get.exe`.
-
-You need to have the following components installed:
-![](https://cloud.githubusercontent.com/assets/282293/5525466/947bf396-89e6-11e4-841d-4aa916f14de1.png)
-
-Next we need to install [git for windows][2]. You probably want to check the option to add it to the global path, but you do not need to install the unix tools.
-
-If you want to run the spec test-suite you also need [ruby][3] and a few gems available. Grab the [latest installer][3] and make sure to add it the global path. Then install the missing gems:
-
-```bash
-gem install minitest
-```
-
-### Mount the mingw root directory
-
-As mentioned in the [MinGW Getting Started](http://www.mingw.org/wiki/Getting_Started#toc5) guide, you should edit `C:\MinGW\msys\1.0\etc\fstab` to contain the following line:
-
-```
-C:\MinGW   /mingw
-```
-
-### Starting a "MingGW" console
-
-Create a batch file with this content:
-```bat
-@echo off
-set PATH=C:\MinGW\bin;%PATH%
-REM only needed if not already available
-set PATH=%PROGRAMFILES%\git\bin;%PATH%
-REM C:\MinGW\msys\1.0\msys.bat
-cmd
-```
-
-Execute it and make sure these commands can be called: `git`, `mingw32-make`, `rm` and `gcc`! Once this is all set, you should be ready to compile `libsass`!
-
-### Get the sources
-
-```bash
-# using git is preferred
-git clone https://github.com/sass/libsass.git
-# only needed for sassc and/or testsuite
-git clone https://github.com/sass/sassc.git libsass/sassc
-git clone https://github.com/sass/sass-spec.git libsass/sass-spec
-```
-
-### Decide for static or shared library
-
-`libsass` can be built and linked as a `static` or as a `shared` library. The default is `static`. To change it you can set the `BUILD` environment variable:
-
-```bat
-set BUILD="shared"
-```
-
-### Compile the library
-```bash
-mingw32-make -C libsass
-```
-
-### Results can be found in
-```bash
-$ ls libsass/lib
-libsass.a  libsass.dll  libsass.so
-```
-
-### Run the spec test-suite
-```bash
-mingw32-make -C libsass test_build
-```
-
-## Building via MingGW 64bit (makefiles)
-Building libass to dll on window 64bit.
-
-Download [MinGW64 for windows7 64bit](http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/4.9.2/threads-win32/seh/x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z/download) and unzip to "C:\mingw64".
-
-Create a batch file with this content:
-
-```bat
-@echo off
-set PATH=C:\mingw64\bin;%PATH%
-set CC=gcc
-REM only needed if not already available
-set PATH=%PROGRAMFILES%\Git\bin;%PATH%
-REM C:\MinGW\msys\1.0\msys.bat
-cmd
-```
-
-By default, mingw64 dll will depends on "​m​i​n​g​w​m​1​0​.​d​l​l​、​ ​l​i​b​g​c​c​_​s​_​d​w​2​-​1​.​d​l​l​", we can modify Makefile to fix this:(add "-static")
-
-``` bash
-lib/libsass.dll: $(COBJECTS) $(OBJECTS) $(RCOBJECTS)
-	$(MKDIR) lib
-	$(CXX) -shared $(LDFLAGS) -o $@ $(COBJECTS) $(OBJECTS) $(RCOBJECTS) $(LDLIBS) -s -static -Wl,--subsystem,windows,--out-implib,lib/libsass.a
-```
-
-Compile the library
-
-```bash
-mingw32-make -C libsass
-```
-
-By the way, if you are using java jna, [JNAerator](http://jnaerator.googlecode.com/) is a good tool.
-
-[1]: http://sourceforge.net/projects/mingw/files/latest/download?source=files
-[2]: https://msysgit.github.io/
-[3]: http://rubyinstaller.org/

data/ext/libsass/docs/build-with-visual-studio.md

@@ -1,90 +0,0 @@
-## Building LibSass with Visual Studio
-
-### Requirements:
-
-The minimum requirement to build LibSass with Visual Studio is "Visual Studio 2013 Express for Desktop".
-
-Additionally, it is recommended to have `git` installed and available in `PATH`, so to deduce the `libsass` version information. For instance, if GitHub for Windows (https://windows.github.com/) is installed, the `PATH` will have an entry resembling: `X:\Users\<YOUR_NAME>\AppData\Local\GitHub\PortableGit_<SOME_GUID>\cmd\` (where `X` is the drive letter of system drive). If `git` is not available, inquiring the LibSass version will result in `[NA]`.
-
-### Build Steps:
-
-#### From Visual Studio:
-
-On opening the `win\libsass.sln` solution and build (Ctrl+Shift+B) to build `libsass.dll`.
-
-To Build LibSass as a static Library, it is recommended to set an environment variable `LIBSASS_STATIC_LIB` before launching the project:
-
-```cmd
-cd path\to\libsass
-SET LIBSASS_STATIC_LIB=1
-::
-:: or in PowerShell:
-:: $env:LIBSASS_STATIC_LIB=1
-::
-win\libsass.sln
-```
-
-Visual Studio will form the filtered source tree as shown below:
-
-![image](https://cloud.githubusercontent.com/assets/3840695/9298985/aae9e072-44bf-11e5-89eb-e7995c098085.png)
-
-`Header Files` contains the .h and .hpp files, while `Source Files` covers `.c` and `.cpp`. The other used headers/sources will appear under `External Dependencies`.
-
-If there is a LibSass code file appearing under External Dependencies, it can be changed by altering the `win\libsass.vcxproj.filters` file or dragging in Solution Explorer.
-
-#### From Command Prompt:
-
-Notice that in the following commands:
-
-* If the platform is 32-bit Windows, replace `ProgramFiles(x86)` with `ProgramFiles`.
-* To build with Visual Studio 2015, replace `12.0` with `14.0` in the aforementioned command.
-
-Open a command prompt:
-
-To build dynamic/shared library (`libsass.dll`):
-
-```cmd
-:: debug build:
-"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln
-
-:: release build:
-"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
-/p:Configuration=Release
-```
-
-To build static library (`libsass.lib`):
-
-```cmd
-:: debug build:
-"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
-/p:LIBSASS_STATIC_LIB=1
-
-:: release build:
-"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
-/p:LIBSASS_STATIC_LIB=1 /p:Configuration=Release
-```
-
-#### From PowerShell:
-
-To build dynamic/shared library (`libsass.dll`):
-
-```powershell
-# debug build:
-&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln
-
-# release build:
-&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
-/p:Configuration=Release
-```
-
-To build static library (`libsass.lib`):
-
-```powershell
-# build:
-&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
-/p:LIBSASS_STATIC_LIB=1
-
-# release build:
-&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
-/p:LIBSASS_STATIC_LIB=1 /p:Configuration=Release
-```

data/ext/libsass/docs/build.md

@@ -1,97 +0,0 @@
-`libsass` is only a library and does not do much on its own. You need an implementation that you can use from the [command line][6]. Or some [bindings|Implementations][9] to use it within your favorite programming language. You should be able to get [`sassc`][6] running by following the instructions in this guide.
-
-Before starting, see [setup dev environment](setup-environment.md).
-
-Building on different Operating Systems
---
-
-We try to keep the code as OS independent and standard compliant as possible. Reading files from the file-system has some OS depending code, but will ultimately fall back to a posix compatible implementation. We do use some `C++11` features, but are so far only committed to use `unordered_map`. This means you will need a pretty recent compiler on most systems (gcc 4.5 seems to be the minimum).
-
-### Building on Linux (and other *nix flavors)
-
-Linux is the main target for `libsass` and we support two ways to build `libsass` here. The old plain makefiles should still work on most systems (including MinGW), while the autotools build is preferred if you want to create a [system library] (experimental).
-
-- [Building with makefiles][1]
-- [Building with autotools][2]
-
-### Building on Windows (experimental)
-
-Windows build support was added very recently and should be considered experimental. Credits go to @darrenkopp and @am11 for their work on getting `libsass` and `sassc` to compile with visual studio!
-
-- [Building with MinGW][3]
-- [Building with Visual Studio][11]
-
-### Building on Max OS X (untested)
-
-Works the same as on linux, but you can also install LibSass via `homebrew`.
-
-- [Building on Mac OS X][10]
-
-### Building a system library (experimental)
-
-Since `libsass` is a library, it makes sense to install it as a shared library on your system. On linux this means creating a `.so` library via autotools. This should work pretty well already, but we are not yet committed to keep the ABI 100% stable. This should be the case once we increase the version number for the library to 1.0.0 or higher. On Windows you should be able get a `dll` by creating a shared build with MinGW. There is currently no target in the MSVC project files to do this.
-
-- [Building shared system library][4]
-
-Compiling with clang instead of gcc
---
-
-To use clang you just need to set the appropriate environment variables:
-
-```bash
-export CC=/usr/bin/clang
-export CXX=/usr/bin/clang++
-```
-
-Running the spec test-suite
---
-
-We constantly and automatically test `libsass` against the official [spec test-suite][5]. To do this we need to have a test-runner (which is written in ruby) and a command-line tool ([`sassc`][6]) to run the tests. Therefore we need to additionally compile `sassc`. To do this, the build files of all three projects need to work together. This may not have the same quality for all build flavors. You definitely need to have ruby (2.1?) installed (version 1.9 seems to cause problems at least on windows). You also need some gems installed:
-
-```bash
-ruby -v
-gem install minitest
-# should be optional
-gem install minitap
-```
-
-Including the LibSass version
---
-
-There is a function in `libsass` to query the current version. This has to be defined at compile time. We use a C macro for this, which can be defined by calling `g++ -DLIBSASS_VERSION="\"x.y.z.\""`. The two quotes are necessary, since it needs to end up as a valid C string. Normally you do not need to do anything if you use the makefiles or autotools. They will try to fetch the version via git directly. If you only have the sources without the git repo, you can pass the version as an environment variable to `make` or `configure`:
-
-```
-export LIBSASS_VERSION="x.y.z."
-```
-
-Continuous Integration
---
-
-We use two CI services to automatically test all commits against the latest [spec test-suite][5].
-
-- [LibSass on Travis-CI (linux)][7]
-[![Build Status](https://travis-ci.org/sass/libsass.png?branch=master)](https://travis-ci.org/sass/libsass)
-- [LibSass on AppVeyor (windows)][8]
-[![Build status](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/mgreter/libsass-513/branch/master)
-
-Why not using CMake?
---
-
-There were some efforts to get `libsass` to compile with CMake, which should make it easier to create build files for linux and windows. Unfortunately this was not completed. But we are certainly open for PRs!
-
-Miscellaneous
---
-
-- [Ebuilds for Gentoo Linux](build-on-gentoo.md)
-
-[1]: build-with-makefiles.md
-[2]: build-with-autotools.md
-[3]: build-with-mingw.md
-[4]: build-shared-library.md
-[5]: https://github.com/sass/sass-spec
-[6]: https://github.com/sass/sassc
-[7]: https://github.com/sass/libsass/blob/master/.travis.yml
-[8]: https://github.com/sass/libsass/blob/master/appveyor.yml
-[9]: implementations.md
-[10]: build-on-darwin.md
-[11]: build-with-visual-studio.md

data/ext/libsass/docs/compatibility-plan.md

@@ -1,48 +0,0 @@
-This document is to serve as a living, changing plan for getting LibSass caught up with Ruby Sass.
-
-_Note: an "s" preceeding a version number is specifying a Ruby Sass version. Without an s, it's a version of LibSass._
-
-# Goal
-**Our goal is to reach full s3.4 compatibility as soon as possible. LibSass version 3.4 will behave just like Ruby Sass 3.4**
-
-I highlight the goal, because there are some things that are *not* currently priorities. To be clear, they WILL be priorities, but they are not at the moment:
-
-* Performance Improvements
-* Extensibility
-
-The overriding goal is correctness.
-
-## Verifying Correctness
-LibSass uses the spec for its testing. The spec was originally based off s3.2 tests. Many things have changed in Ruby Sass since then and some of the tests need to be updated and changed in order to get them to match both LibSass and Ruby Sass.
-
-Until this project is complete, the spec will be primarily a place to test LibSass. By the time LibSass reaches 3.4, it is our goal that sass-spec will be fully usable as an official testing source for ALL implementations of Sass.
-
-## Version Naming
-Until LibSass reaches parity with Ruby Sass, we will be aggressively bumping versions, and LibSass 3.4 will be the peer to Ruby Sass 3.4 in every way.
-
-# Release Plan
-
-## 3.0
-The goal of 3.0 is to introduce some of the most demanded features for LibSass. That is, we are focusing on issues and features that have kept adoption down. This is a mongrel release wrt which version of Sass it's targeting. It's often a mixture of 3.2 / 3.3 / 3.4 behaviours. This is not ideal, but it's favourable to not existing. Targeting 3.4 strictly during this release would mean we never actually release.
-
-# 3.1
-The goal of 3.1 is to update all the passing specs to agree with 3.4. This will not be a complete representation of s3.4 (aka, there will me missing features), but the goal is to change existing features and implemented features to match 3.4 behaviour.
-
-By the end of this, the sass-spec must pass against 3.4.
-
-Major issues:
-* Variable Scoping
-* Color Handling
-* Precision
-
-# 3.2
-This version will focus on edge case fixes. There are a LOT of edge cases in the _todo_ tests and this is the release where we hunt those down like dogs (not that we want to hurt dogs, it's just a figure of speech in English).
-
-# 3.3
-Dress rehearsal. When we are 99% sure that we've fixed the main issues keeping us from saying we are compliant in s3.4 behaviour.
-
-# 3.4
-Compass Compatibility. We need to be able to work with Compass and all the other libraries out there. At this point, we are calling LibSass "mature"
-
-# Beyond 3.4
-Obviously, there is matching Sass 3.5 behaviour. But, beyond that, we'll want to focus on performance, stability, and error handling. These can always be improved upon and are the life's work of an open source project. We'll have to work closely with Sass in the future.

data/ext/libsass/docs/contributing.md

@@ -1,17 +0,0 @@
-First of all, welcome! Thanks for even reading this page. If you're here, you're probably wondering what you can do to help make the LibSass project even more awesome. And, even having that feeling means you are awesome!
-
-## I'm a programmer
-
-Awesome! We need your help. The best thing to do is go find issues that are tagged with both "bug" and "test written". We do spec driven development here and these issues have a test that's written already in the sass-spec project. Go find the test by going to sass-spec/spec/LibSass-todo-issues/issue_XXX/ where XXX is the issue number. Write the code, and compile, and then issue a pull request referencing the issue. We'll quickly verify it and get it merged in!
-
-To get your dev environment setup, check out our article on [Setup-Dev-Environment](setup-environment.md).
-
-## I'm not a backend programmer
-
-COOL! We also need your help. Doing [Issue-Triage](triage.md) is a big deal and something we need constant help with. That means helping to verify issues, write tests for them, and make sure they are getting fixed. It's being part of the smiling face of the project.
-
-Also, we need help with the Sass-Spec project itself. Just people to organize, refactor, and understand the tests in there.
-
-## I don't know what a computer is?
-
-Hmm.... well, it's the thing you are looking at right now. Ummm... check out training courses! Then, come back and join us!

data/ext/libsass/docs/custom-functions-internal.md

@@ -1,122 +0,0 @@
-# Developer Documentation
-
-Custom functions are internally represented by `struct Sass_C_Function_Descriptor`.
-
-## Sass_C_Function_Descriptor
-
-```C
-struct Sass_C_Function_Descriptor {
-  const char*      signature;
-  Sass_C_Function  function;
-  void*            cookie;
-};
-```
-
-- `signature`: The function declaration, like `foo($bar, $baz:1)`
-- `function`:  Reference to the C function callback
-- `cookie`:    any pointer you want to attach
-
-### signature
-
-The signature defines how the function can be invoked. It also declares which arguments are required and which are optional.  Required arguments will be enforced by LibSass and a Sass error is thrown in the event a call as missing an argument. Optional arguments only need to be present when you want to overwrite the default value.
-
-    foo($bar, $baz: 2)
-
-In this example, `$bar` is required and will error if not passed. `$baz` is optional and the default value of it is 2. A call like `foo(10)` is therefore equal to `foo(10, 2)`, while `foo()` will produce an error.
-
-### function
-
-The callback function needs to be of the following form:
-
-```C
-union Sass_Value* call_sass_function(
-    const union Sass_Value* s_args,
-    void*                   cookie
-) {
-  return sass_clone_value(s_args);
-}
-```
-
-### cookie
-
-The cookie can hold any pointer you want. In the `perl-libsass` implementation it holds the structure with the reference of the actual registered callback into the perl interpreter. Before that call `perl-libsass` will convert all `Sass_Values` to corresponding perl data types (so they can be used natively inside the perl interpretor). The callback can also return a `Sass_Value`. In `perl-libsass` the actual function returns a perl value, which has to be converted before `libsass` can work with it again!
-
-## Sass_Values
-
-```C
-// allocate memory (copies passed strings)
-union Sass_Value* sass_make_null    (void);
-union Sass_Value* sass_make_boolean (bool val);
-union Sass_Value* sass_make_string  (const char* val);
-union Sass_Value* sass_make_qstring (const char* val);
-union Sass_Value* sass_make_number  (double val, const char* unit);
-union Sass_Value* sass_make_color   (double r, double g, double b, double a);
-union Sass_Value* sass_make_list    (size_t len, enum Sass_Separator sep, bool is_bracketed);
-union Sass_Value* sass_make_map     (size_t len);
-union Sass_Value* sass_make_error   (const char* msg);
-union Sass_Value* sass_make_warning (const char* msg);
-
-// Make a deep cloned copy of the given sass value
-union Sass_Value* sass_clone_value (const union Sass_Value* val);
-
-// deallocate memory (incl. all copied memory)
-void sass_delete_value (const union Sass_Value* val);
-```
-
-## Example main.c
-
-```C
-#include <stdio.h>
-#include <stdint.h>
-#include "sass/context.h"
-
-union Sass_Value* call_fn_foo(const union Sass_Value* s_args, void* cookie)
-{
-  // we actually abuse the void* to store an "int"
-  return sass_make_number((size_t)cookie, "px");
-}
-
-int main( int argc, const char* argv[] )
-{
-
-  // get the input file from first argument or use default
-  const char* input = argc > 1 ? argv[1] : "styles.scss";
-
-  // create the file context and get all related structs
-  struct Sass_File_Context* file_ctx = sass_make_file_context(input);
-  struct Sass_Context* ctx = sass_file_context_get_context(file_ctx);
-  struct Sass_Options* ctx_opt = sass_context_get_options(ctx);
-
-  // 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);
-  sass_function_set_list_entry(fn_list, 0, fn_foo);
-  sass_option_set_c_functions(ctx_opt, fn_list);
-
-  // context is set up, call the compile step now
-  int status = sass_compile_file_context(file_ctx);
-
-  // print the result or the error to the stdout
-  if (status == 0) puts(sass_context_get_output_string(ctx));
-  else puts(sass_context_get_error_message(ctx));
-
-  // release allocated memory
-  sass_delete_file_context(file_ctx);
-
-  // exit status
-  return status;
-
-}
-```
-
-## Compile main.c
-
-```bash
-gcc -c main.c -o main.o
-gcc -o sample main.o -lsass
-echo "foo { margin: foo(); }" > foo.scss
-./sample foo.scss => "foo { margin: 42px }"
-```