sassc 0.0.1

data/ext/libsass/Makefile.am

@@ -0,0 +1,145 @@
+ACLOCAL_AMFLAGS = -I m4
+
+AM_LDFLAGS = -lstdc++ -lm
+AM_CFLAGS = -Wall -fPIC
+AM_CXXFLAGS = -Wall -fPIC
+AM_CFLAGS += -DLIBSASS_VERSION="\"$(LIBSASS_VERSION)\""
+AM_CXXFLAGS += -DLIBSASS_VERSION="\"$(LIBSASS_VERSION)\""
+
+AM_CXXFLAGS += -std=c++0x
+
+if ENABLE_COVERAGE
+	AM_CFLAGS += -O0 --coverage
+	AM_CXXFLAGS += -O0 --coverage
+	AM_LDFLAGS += -O0 --coverage -lgcov
+else
+	AM_CFLAGS += -O2
+	AM_CXXFLAGS += -O2
+	AM_LDFLAGS += -O2
+endif
+
+VERSION = $(LIBSASS_VERSION)
+
+EXTRA_DIST = \
+	COPYING \
+	INSTALL \
+	LICENSE \
+	Readme.md
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = support/libsass.pc
+
+lib_LTLIBRARIES = libsass.la
+
+libsass_la_SOURCES = \
+	ast_fwd_decl.hpp ast_def_macros.hpp \
+	kwd_arg_macros.hpp memory_manager.hpp \
+	position.hpp operation.hpp \
+	subset_map.hpp mapping.hpp \
+	color_names.hpp backtrace.hpp \
+	cencode.c b64/cencode.h b64/encode.h \
+	token.hpp environment.hpp \
+	paths.hpp debug.hpp \
+	utf8.h utf8/core.h \
+	utf8/checked.h utf8/unchecked.h \
+	ast.cpp ast.hpp \
+	base64vlq.cpp base64vlq.hpp \
+	bind.cpp bind.hpp \
+	constants.cpp constants.hpp \
+	context.cpp context.hpp \
+	contextualize.cpp contextualize.hpp \
+	copy_c_str.cpp copy_c_str.hpp \
+	error_handling.cpp error_handling.hpp \
+	eval.cpp eval.hpp \
+	expand.cpp expand.hpp \
+	extend.cpp extend.hpp \
+	file.cpp file.hpp \
+	functions.cpp functions.hpp \
+	inspect.cpp inspect.hpp \
+	node.cpp node.hpp \
+	json.cpp json.hpp \
+	output_compressed.cpp output_compressed.hpp \
+	output_nested.cpp output_nested.hpp \
+	parser.cpp parser.hpp \
+	prelexer.cpp prelexer.hpp \
+	remove_placeholders.cpp remove_placeholders.hpp \
+	sass.cpp sass.h \
+	sass_util.cpp sass_util.hpp \
+	sass_values.cpp sass_values.h \
+	sass_context.cpp sass_context.h \
+	sass_functions.cpp sass_functions.h \
+	sass_interface.cpp sass_interface.h \
+	sass2scss.cpp sass2scss.h \
+	source_map.cpp source_map.hpp \
+	to_c.cpp to_c.hpp \
+	to_string.cpp to_string.hpp \
+	units.cpp units.hpp \
+	utf8_string.cpp utf8_string.hpp \
+	util.cpp util.hpp
+
+libsass_la_CFLAGS = $(AM_CFLAGS)
+libsass_la_CXXFLAGS = $(AM_CXXFLAGS)
+libsass_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 0:9:0
+
+include_HEADERS = sass2scss.h sass_context.h sass_functions.h sass_values.h sass.h
+
+if ENABLE_TESTS
+
+noinst_PROGRAMS = sassc_bin
+
+sassc_bin_SOURCES = $(SASS_SASSC_PATH)/sassc.c
+sassc_bin_LDADD = libsass.la
+sassc_bin_CFLAGS = $(AM_CFLAGS)
+sassc_bin_CXXFLAGS = $(AM_CXXFLAGS)
+sassc_bin_LDFLAGS = $(AM_LDFLAGS) -no-install
+
+if ENABLE_COVERAGE
+nodist_EXTRA_sassc_bin_SOURCES = non-existent-file-to-force-CXX-linking.cxx
+nodist_EXTRA_libsass_la_SOURCES = non-existent-file-to-force-CXX-linking.cxx
+endif
+
+SASS_SASSC_PATH ?= sassc
+SASS_SPEC_PATH ?= sass-spec
+SASSC_BIN = $(SASS_SASSC_PATH)/bin/sassc
+
+TESTS = \
+	$(SASS_SPEC_PATH)/spec/basic \
+	$(SASS_SPEC_PATH)/spec/css \
+	$(SASS_SPEC_PATH)/spec/extend-tests \
+	$(SASS_SPEC_PATH)/spec/extends \
+	$(SASS_SPEC_PATH)/spec/libsass \
+	$(SASS_SPEC_PATH)/spec/libsass-closed-issues \
+	$(SASS_SPEC_PATH)/spec/maps \
+	$(SASS_SPEC_PATH)/spec/misc \
+	$(SASS_SPEC_PATH)/spec/regressions \
+	$(SASS_SPEC_PATH)/spec/scss \
+	$(SASS_SPEC_PATH)/spec/scss-tests \
+	$(SASS_SPEC_PATH)/spec/types
+
+SASS_TEST_FLAGS =
+LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) ./script/tap-driver
+AM_LOG_FLAGS = -c ./sassc_bin --ignore-todo $(LOG_FLAGS)
+if USE_TAP
+	AM_LOG_FLAGS += -t
+	SASS_TEST_FLAGS += -t | tapout
+	LOG_COMPILER = ./script/tap-runner $(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb
+else
+	LOG_COMPILER = $(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb
+endif
+
+$(SASSC_BIN): libsass.la
+	cd $(SASS_SASSC_PATH) && $(MAKE)
+
+test: $(SASSC_BIN)
+	$(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb -c $(SASSC_BIN) --ignore-todo $(LOG_FLAGS) $(SASS_SPEC_PATH) $(SASS_TEST_FLAGS)
+
+test_build: $(SASSC_BIN)
+	$(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb -c $(SASSC_BIN) --ignore-todo $(LOG_FLAGS) $(SASS_SPEC_PATH) $(SASS_TEST_FLAGS)
+
+test_full: $(SASSC_BIN)
+	$(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb -c $(SASSC_BIN) $(LOG_FLAGS) $(SASS_SPEC_PATH) $(SASS_TEST_FLAGS)
+
+test_issues: $(SASSC_BIN)
+	$(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb -c $(SASSC_BIN) $(LOG_FLAGS) $(SASS_SPEC_PATH)/spec/issues $(SASS_TEST_FLAGS)
+
+endif

data/ext/libsass/Readme.md

@@ -0,0 +1,93 @@
+Libsass
+=======
+
+by Aaron Leung ([@akhleung]) and Hampton Catlin ([@hcatlin])
+
+[![Linux CI](https://travis-ci.org/sass/libsass.png?branch=master)](https://travis-ci.org/sass/libsass)
+[![Windows CI](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/sass/libsass/branch/master)
+[![Bountysource](https://www.bountysource.com/badge/tracker?tracker_id=283068)](https://www.bountysource.com/trackers/283068-libsass?utm_source=283068&utm_medium=shield&utm_campaign=TRACKER_BADGE)
+[![Coverage Status](https://img.shields.io/coveralls/sass/libsass.svg)](https://coveralls.io/r/sass/libsass?branch=feature%2Ftest-travis-ci-3)
+
+https://github.com/sass/libsass
+
+Libsass is just a library, but if you want to RUN libsass,
+then go to https://github.com/sass/sassc or
+https://github.com/sass/ruby-libsass or
+[find your local implementer](https://github.com/sass/libsass/wiki/Implementations).
+
+LibSass requires GCC 4.5+ or Clang/LLVM. If your OS is older, this version may not compile.
+
+About
+-----
+
+Libsass is a C/C++ port of the Sass CSS precompiler. The original version was written in Ruby, but this version is meant for efficiency and portability.
+
+This library strives to be light, simple, and easy to build and integrate with a variety of platforms and languages.
+
+Developing
+----------
+
+As you may have noticed, the libsass repo itself has
+no executables and no tests. Oh noes! How can you develop???
+
+Well, luckily, SassC is the official binary wrapper for
+libsass and is *always* kept in sync. SassC uses a git submodule
+to include libsass. When developing libsass, its best to actually
+check out SassC and develop in that directory with the SassC spec
+and tests there.
+
+We even run Travis tests for SassC!
+
+Tests
+-------
+
+Since libsass is a pure library, tests are run through the [SassSpec](https://github.com/sass/sass-spec) project using the [SassC](http://github.com/sass/sassc) driver.
+
+To run tests against libsass while developing, you can run `./script/spec`. This will clone SassC and Sass-Spec under the project folder and then run the Sass-Spec test suite. You may want to update the clones to ensure you have the latest version.
+
+Library Usage
+-------------
+
+While libsass is a library primarily written in C++, it provides a simple
+C interface which should be used by most implementers. Libsass does not do
+much on its own without an implementer. This can be a command line tool, like
+[sassc](https://github.com/sass/sassc) or a [binding](https://github.com/sass/libsass/wiki/Implementations)
+to your favorite programing language.
+
+If you want to build or interface with libsass, we recommend to check out the
+wiki pages about [building libsass](https://github.com/sass/libsass/wiki/Building-Libsass) and
+the [C-API documentation](https://github.com/sass/libsass/wiki/API-Documentation).
+
+About Sass
+----------
+
+Sass is a CSS pre-processor language to add on exciting, new,
+awesome features to CSS. Sass was the first language of its kind
+and by far the most mature and up to date codebase.
+
+Sass was originally created by the co-creator of this library,
+Hampton Catlin ([@hcatlin]). The extension and continuing evolution
+of the language has all been the result of years of work by Natalie
+Weizenbaum ([@nex3]) and Chris Eppstein ([@chriseppstein]).
+
+For more information about Sass itself, please visit http://sass-lang.com
+
+Contribution Agreement
+----------------------
+
+Any contribution to the project are seen as copyright assigned to Hampton Catlin, a
+human on the planet earth. Your contribution warrants that you have the right to
+assign copyright on your work. The intention here is to ensure that the project
+remains totally free (liberal, like).
+
+Our MIT license is designed to be as simple, and liberal as possible.
+
+[@hcatlin]: https://github.com/hcatlin
+[@akhleung]: https://github.com/akhleung
+[@chriseppstein]: https://github.com/chriseppstein
+[@nex3]: https://github.com/nex3
+
+sass2scss was originally written by Marcel Greter [@mgreter]
+and he happily agreed to have it merged into the project.
+
+[sass_interface.h]: sass_interface.h

data/ext/libsass/appveyor.yml

@@ -0,0 +1,76 @@
+environment:
+  CTEST_OUTPUT_ON_FAILURE: 1
+  matrix:
+  - Compiler: mingw
+    Build: static
+    ruby_version: "21-x64"
+  - Compiler: mingw
+    Build: shared
+    ruby_version: "21-x64"
+  - Compiler: msvc
+    Config: Release
+    ruby_version: "21-x64"
+  - Compiler: msvc
+    Config: Debug
+    ruby_version: "21-x64"
+
+cache:
+  - x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z
+  - C:\Ruby21-x64\lib\ruby\gems\2.1.0
+  - C:\Ruby21-x64\bin
+
+install:
+  - git clone https://github.com/sass/sassc.git
+  - git clone https://github.com/sass/sass-spec.git
+  - set PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - set SASS_LIBSASS_PATH=..
+  - gem install minitest
+  - ps: |
+      if ($env:Compiler -eq "mingw") {
+        if (-Not (Test-Path "x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z")) {
+          # Install MinGW.
+          $url  = "http://sourceforge.net/projects/mingw-w64/files/"
+          $url += "Toolchains%20targetting%20Win64/Personal%20Builds/"
+          $url += "mingw-builds/4.9.2/threads-win32/seh/"
+          $url += "x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z/download"
+          Invoke-WebRequest -UserAgent wget -Uri $url -OutFile x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z
+        }
+        &7z x -oC:\ x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z > $null
+      }
+  - set PATH=C:\mingw64\bin;%PATH%
+  - set CC=gcc
+
+build_script:
+  - ps: |
+      if ($env:Compiler -eq "mingw") {
+        mingw32-make -j4 sassc
+      } else {
+        msbuild /m:4 /p:Configuration=$env:Config win\libsass.sln
+      }
+  - ps: |
+      if ($env:Compiler -eq "mingw") {
+        sassc\bin\sassc.exe -v
+        ruby -v
+      } else {
+        if ($env:Config -eq "Debug") {
+          win\bin\Debug\sassc.exe -v
+          ruby -v
+        } else {
+          win\bin\sassc.exe -v
+          ruby -v
+        }
+      }
+
+test_script:
+  - ps: |
+      if ($env:Compiler -eq "mingw") {
+        ruby sass-spec\sass-spec.rb -c sassc\bin\sassc.exe -s --ignore-todo sass-spec/spec
+      } else {
+        if ($env:Config -eq "Debug") {
+          echo test runner in debug mode build via msvc will throw debug assertions
+          echo ruby sass-spec\sass-spec.rb -c win\bin\Debug\sassc.exe -s --ignore-todo sass-spec/spec
+        } else {
+          ruby sass-spec\sass-spec.rb -c win\bin\sassc.exe -s --ignore-todo sass-spec/spec
+        }
+      }
+

data/ext/libsass/ast.cpp

@@ -0,0 +1,581 @@
+#include "ast.hpp"
+#include "context.hpp"
+#include "to_string.hpp"
+#include <set>
+#include <algorithm>
+#include <iostream>
+
+namespace Sass {
+  using namespace std;
+
+  bool Compound_Selector::operator<(const Compound_Selector& rhs) const
+  {
+    To_String to_string;
+    // ugly
+    return const_cast<Compound_Selector*>(this)->perform(&to_string) <
+           const_cast<Compound_Selector&>(rhs).perform(&to_string);
+  }
+
+  bool Complex_Selector::operator<(const Complex_Selector& rhs) const
+  {
+    To_String to_string;
+    return const_cast<Complex_Selector*>(this)->perform(&to_string) <
+           const_cast<Complex_Selector&>(rhs).perform(&to_string);
+  }
+  
+  bool Complex_Selector::operator==(const Complex_Selector& rhs) const {
+  	// TODO: We have to access the tail directly using tail_ since ADD_PROPERTY doesn't provide a const version.
+
+  	const Complex_Selector* pOne = this;
+    const Complex_Selector* pTwo = &rhs;
+    
+    // Consume any empty references at the beginning of the Complex_Selector
+    if (pOne->combinator() == Complex_Selector::ANCESTOR_OF && pOne->head()->is_empty_reference()) {
+    	pOne = pOne->tail_;
+    }
+    if (pTwo->combinator() == Complex_Selector::ANCESTOR_OF && pTwo->head()->is_empty_reference()) {
+    	pTwo = pTwo->tail_;
+    }
+    
+    while (pOne && pTwo) {
+    	if (pOne->combinator() != pTwo->combinator()) {
+      	return false;
+      }
+      
+      if (*(pOne->head()) != *(pTwo->head())) {
+      	return false;
+      }
+
+    	pOne = pOne->tail_;
+      pTwo = pTwo->tail_;
+    }
+    
+    return pOne == NULL && pTwo == NULL;
+  }
+
+  Compound_Selector* Compound_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  {
+    Compound_Selector* unified = rhs;
+    for (size_t i = 0, L = length(); i < L; ++i)
+    {
+      if (!unified) break;
+      else          unified = (*this)[i]->unify_with(unified, ctx);
+    }
+    return unified;
+  }
+  
+  bool Simple_Selector::operator==(const Simple_Selector& rhs) const
+  {
+  	// Compare the string representations for equality.
+
+  	// Cast away const here. To_String should take a const object, but it doesn't.
+  	Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
+    Simple_Selector* pRHS = const_cast<Simple_Selector*>(&rhs);
+
+    To_String to_string;
+    return pLHS->perform(&to_string) == pRHS->perform(&to_string);
+  }
+  
+  bool Simple_Selector::operator<(const Simple_Selector& rhs) const {
+		// Use the string representation for ordering.
+
+  	// Cast away const here. To_String should take a const object, but it doesn't.
+  	Simple_Selector* pLHS = const_cast<Simple_Selector*>(this);
+    Simple_Selector* pRHS = const_cast<Simple_Selector*>(&rhs);
+    
+    To_String to_string;
+    return pLHS->perform(&to_string) < pRHS->perform(&to_string);
+  }
+
+  Compound_Selector* Simple_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  {
+    To_String to_string;
+    for (size_t i = 0, L = rhs->length(); i < L; ++i)
+    { if (perform(&to_string) == (*rhs)[i]->perform(&to_string)) return rhs; }
+
+    // check for pseudo elements because they need to come last
+    size_t i, L;
+    bool found = false;
+    if (typeid(*this) == typeid(Pseudo_Selector) || typeid(*this) == typeid(Wrapped_Selector))
+    {
+      for (i = 0, L = rhs->length(); i < L; ++i)
+      {
+        if ((typeid(*(*rhs)[i]) == typeid(Pseudo_Selector) || typeid(*(*rhs)[i]) == typeid(Wrapped_Selector)) && (*rhs)[L-1]->is_pseudo_element())
+        { found = true; break; }
+      }  
+    }
+    else
+    {
+      for (i = 0, L = rhs->length(); i < L; ++i)
+      {
+        if (typeid(*(*rhs)[i]) == typeid(Pseudo_Selector) || typeid(*(*rhs)[i]) == typeid(Wrapped_Selector))
+        { found = true; break; }
+      }
+    }
+    if (!found)
+    {
+      Compound_Selector* cpy = new (ctx.mem) Compound_Selector(*rhs);
+      (*cpy) << this;
+      return cpy;
+    }
+    Compound_Selector* cpy = new (ctx.mem) Compound_Selector(rhs->path(), rhs->position());
+    for (size_t j = 0; j < i; ++j)
+    { (*cpy) << (*rhs)[j]; }
+    (*cpy) << this;
+    for (size_t j = i; j < L; ++j)
+    { (*cpy) << (*rhs)[j]; }
+    return cpy;
+  }
+
+  Compound_Selector* Type_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  {
+    // TODO: handle namespaces
+
+    // if the rhs is empty, just return a copy of this
+    if (rhs->length() == 0) {
+      Compound_Selector* cpy = new (ctx.mem) Compound_Selector(rhs->path(), rhs->position());
+      (*cpy) << this;
+      return cpy;
+    }
+
+    // if this is a universal selector and rhs is not empty, just return the rhs
+    if (name() == "*")
+    { return new (ctx.mem) Compound_Selector(*rhs); }
+    
+
+    Simple_Selector* rhs_0 = (*rhs)[0];
+    // otherwise, this is a tag name
+    if (typeid(*rhs_0) == typeid(Type_Selector))
+    {
+      // if rhs is universal, just return this tagname + rhs's qualifiers
+      if (static_cast<Type_Selector*>(rhs_0)->name() == "*")
+      {
+        Compound_Selector* cpy = new (ctx.mem) Compound_Selector(rhs->path(), rhs->position());
+        (*cpy) << this;
+        for (size_t i = 1, L = rhs->length(); i < L; ++i)
+        { (*cpy) << (*rhs)[i]; }
+        return cpy;
+      }
+      // if rhs is another tag name and it matches this, return rhs
+      else if (static_cast<Type_Selector*>(rhs_0)->name() == name())
+      { return new (ctx.mem) Compound_Selector(*rhs); }
+      // else the tag names don't match; return nil
+      else
+      { return 0; }
+    }
+    // else it's a tag name and a bunch of qualifiers -- just append them
+    Compound_Selector* cpy = new (ctx.mem) Compound_Selector(rhs->path(), rhs->position());
+    (*cpy) << this;
+    (*cpy) += rhs;
+    return cpy;
+  }
+
+  Compound_Selector* Selector_Qualifier::unify_with(Compound_Selector* rhs, Context& ctx)
+  {
+    if (name()[0] == '#')
+    {
+      for (size_t i = 0, L = rhs->length(); i < L; ++i)
+      {
+        Simple_Selector* rhs_i = (*rhs)[i];
+        if (typeid(*rhs_i) == typeid(Selector_Qualifier) &&
+            static_cast<Selector_Qualifier*>(rhs_i)->name()[0] == '#' &&
+            static_cast<Selector_Qualifier*>(rhs_i)->name() != name())
+          return 0;
+      }
+    }
+    return Simple_Selector::unify_with(rhs, ctx);
+  }
+
+  Compound_Selector* Pseudo_Selector::unify_with(Compound_Selector* rhs, Context& ctx)
+  {
+    if (is_pseudo_element())
+    {
+      for (size_t i = 0, L = rhs->length(); i < L; ++i)
+      {
+        Simple_Selector* rhs_i = (*rhs)[i];
+        if (typeid(*rhs_i) == typeid(Pseudo_Selector) &&
+            static_cast<Pseudo_Selector*>(rhs_i)->is_pseudo_element() &&
+            static_cast<Pseudo_Selector*>(rhs_i)->name() != name())
+        { return 0; }
+      }
+    }
+    return Simple_Selector::unify_with(rhs, ctx);
+  }
+
+  bool Compound_Selector::is_superselector_of(Compound_Selector* rhs)
+  {
+    To_String to_string;
+
+    Simple_Selector* lbase = base();
+    Simple_Selector* rbase = rhs->base();
+    
+    // Check if pseudo-elements are the same between the selectors
+    
+    set<string> lpsuedoset, rpsuedoset;
+    for (size_t i = 0, L = length(); i < L; ++i)
+    {
+    	if ((*this)[i]->is_pseudo_element()) {
+      	string pseudo((*this)[i]->perform(&to_string));
+        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
+      	lpsuedoset.insert(pseudo);
+      }
+    }
+    for (size_t i = 0, L = rhs->length(); i < L; ++i)
+    {
+    	if ((*rhs)[i]->is_pseudo_element()) {
+      	string pseudo((*rhs)[i]->perform(&to_string));
+        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
+	    	rpsuedoset.insert(pseudo);
+      }
+    }
+  	if (lpsuedoset != rpsuedoset) {
+      return false;
+    }
+
+		// Check the Simple_Selectors
+
+    set<string> lset, rset;
+
+    if (!lbase) // no lbase; just see if the left-hand qualifiers are a subset of the right-hand selector
+    {
+      for (size_t i = 0, L = length(); i < L; ++i)
+      { lset.insert((*this)[i]->perform(&to_string)); }
+      for (size_t i = 0, L = rhs->length(); i < L; ++i)
+      { rset.insert((*rhs)[i]->perform(&to_string)); }
+      return includes(rset.begin(), rset.end(), lset.begin(), lset.end());
+    }
+    else { // there's an lbase
+      for (size_t i = 1, L = length(); i < L; ++i)
+      { lset.insert((*this)[i]->perform(&to_string)); }
+      if (rbase)
+      {
+        if (lbase->perform(&to_string) != rbase->perform(&to_string)) // if there's an rbase, make sure they match
+        { return false; }
+        else // the bases do match, so compare qualifiers
+        {
+          for (size_t i = 1, L = rhs->length(); i < L; ++i)
+          { rset.insert((*rhs)[i]->perform(&to_string)); }
+          return includes(rset.begin(), rset.end(), lset.begin(), lset.end());
+        }
+      }
+    }
+    // catch-all
+    return false;
+  }
+  
+  bool Compound_Selector::operator==(const Compound_Selector& rhs) const {
+    To_String to_string;
+    
+    // Check if pseudo-elements are the same between the selectors
+    
+    set<string> lpsuedoset, rpsuedoset;
+    for (size_t i = 0, L = length(); i < L; ++i)
+    {
+    	if ((*this)[i]->is_pseudo_element()) {
+      	string pseudo((*this)[i]->perform(&to_string));
+        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
+      	lpsuedoset.insert(pseudo);
+      }
+    }
+    for (size_t i = 0, L = rhs.length(); i < L; ++i)
+    {
+    	if (rhs[i]->is_pseudo_element()) {
+      	string pseudo(rhs[i]->perform(&to_string));
+        pseudo = pseudo.substr(pseudo.find_first_not_of(":")); // strip off colons to ensure :after matches ::after since ruby sass is forgiving
+	    	rpsuedoset.insert(pseudo);
+      }
+    }
+  	if (lpsuedoset != rpsuedoset) {
+      return false;
+    }
+
+		// Check the base
+    
+    const Simple_Selector* const lbase = base();
+    const Simple_Selector* const rbase = rhs.base();
+    
+    if ((lbase && !rbase) ||
+    	(!lbase && rbase) ||
+      ((lbase && rbase) && (*lbase != *rbase))) {
+			return false;
+    }
+    
+    
+    // Check the rest of the SimpleSelectors
+    // Use string representations. We can't create a set of Simple_Selector pointers because std::set == std::set is going to call ==
+    // on the pointers to determine equality. I don't know of a way to pass in a comparison object. The one you can specify as part of
+    // the template type is used for ordering, but not equality. We also can't just put in non-pointer Simple_Selectors because the
+    // class is intended to be subclassed, and we'd get splicing.
+    
+    set<string> lset, rset;
+    
+    for (size_t i = 0, L = length(); i < L; ++i)
+    { lset.insert((*this)[i]->perform(&to_string)); }
+    for (size_t i = 0, L = rhs.length(); i < L; ++i)
+    { rset.insert(rhs[i]->perform(&to_string)); }
+    
+    return lset == rset;
+  }
+  
+  bool Complex_Selector_Pointer_Compare::operator() (const Complex_Selector* const pLeft, const Complex_Selector* const pRight) const {
+    return *pLeft < *pRight;
+  }
+
+  bool Complex_Selector::is_superselector_of(Compound_Selector* rhs)
+  {
+    if (length() != 1)
+    { return false; }
+    return base()->is_superselector_of(rhs);
+  }
+
+  bool Complex_Selector::is_superselector_of(Complex_Selector* rhs)
+  {
+    Complex_Selector* lhs = this;
+    To_String to_string;
+    // check for selectors with leading or trailing combinators
+    if (!lhs->head() || !rhs->head())
+    { return false; }
+    Complex_Selector* l_innermost = lhs->innermost();
+    if (l_innermost->combinator() != Complex_Selector::ANCESTOR_OF && !l_innermost->tail())
+    { return false; }
+    Complex_Selector* r_innermost = rhs->innermost();
+    if (r_innermost->combinator() != Complex_Selector::ANCESTOR_OF && !r_innermost->tail())
+    { return false; }
+    // more complex (i.e., longer) selectors are always more specific
+    size_t l_len = lhs->length(), r_len = rhs->length();
+    if (l_len > r_len)
+    { return false; }
+
+    if (l_len == 1)
+    { return lhs->head()->is_superselector_of(rhs->base()); }
+
+    bool found = false;
+    Complex_Selector* marker = rhs;
+    for (size_t i = 0, L = rhs->length(); i < L; ++i) {
+      if (i == L-1)
+      { return false; }
+      if (lhs->head()->is_superselector_of(marker->head()))
+      { found = true; break; }
+      marker = marker->tail();
+    }
+    if (!found)
+    { return false; }
+
+    /* 
+      Hmm, I hope I have the logic right:
+
+      if lhs has a combinator:
+        if !(marker has a combinator) return false
+        if !(lhs.combinator == '~' ? marker.combinator != '>' : lhs.combinator == marker.combinator) return false
+        return lhs.tail-without-innermost.is_superselector_of(marker.tail-without-innermost)
+      else if marker has a combinator:
+        if !(marker.combinator == ">") return false
+        return lhs.tail.is_superselector_of(marker.tail)
+      else
+        return lhs.tail.is_superselector_of(marker.tail)
+    */
+    if (lhs->combinator() != Complex_Selector::ANCESTOR_OF)
+    {
+      if (marker->combinator() == Complex_Selector::ANCESTOR_OF)
+      { return false; }
+      if (!(lhs->combinator() == Complex_Selector::PRECEDES ? marker->combinator() != Complex_Selector::PARENT_OF : lhs->combinator() == marker->combinator()))
+      { return false; }
+      return lhs->tail()->is_superselector_of(marker->tail());
+    }
+    else if (marker->combinator() != Complex_Selector::ANCESTOR_OF)
+    {
+      if (marker->combinator() != Complex_Selector::PARENT_OF)
+      { return false; }
+      return lhs->tail()->is_superselector_of(marker->tail());
+    }
+    else
+    {
+      return lhs->tail()->is_superselector_of(marker->tail());
+    }
+    // catch-all
+    return false;
+  }
+
+  size_t Complex_Selector::length()
+  {
+    // TODO: make this iterative
+    if (!tail()) return 1;
+    return 1 + tail()->length();
+  }
+
+  Compound_Selector* Complex_Selector::base()
+  {
+    if (!tail()) return head();
+    else return tail()->base();
+  }
+
+  Complex_Selector* Complex_Selector::context(Context& ctx)
+  {
+    if (!tail()) return 0;
+    if (!head()) return tail()->context(ctx);
+    return new (ctx.mem) Complex_Selector(path(), position(), combinator(), head(), tail()->context(ctx));
+  }
+
+  Complex_Selector* Complex_Selector::innermost()
+  {
+    if (!tail()) return this;
+    else         return tail()->innermost();
+  }
+
+  Complex_Selector::Combinator Complex_Selector::clear_innermost()
+  {
+    Combinator c;
+    if (!tail() || tail()->length() == 1)
+    { c = combinator(); combinator(ANCESTOR_OF); tail(0); }
+    else
+    { c = tail()->clear_innermost(); }
+    return c;
+  }
+
+  void Complex_Selector::set_innermost(Complex_Selector* val, Combinator c)
+  {
+    if (!tail())
+    { tail(val); combinator(c); }
+    else
+    { tail()->set_innermost(val, c); }
+  }
+
+  Complex_Selector* Complex_Selector::clone(Context& ctx) const
+  {
+    Complex_Selector* cpy = new (ctx.mem) Complex_Selector(*this);
+    if (tail()) cpy->tail(tail()->clone(ctx));
+    return cpy;
+  }
+  
+  Complex_Selector* Complex_Selector::cloneFully(Context& ctx) const
+  {
+    Complex_Selector* cpy = new (ctx.mem) Complex_Selector(*this);
+
+		if (head()) {
+    	cpy->head(head()->clone(ctx));
+    }
+
+    if (tail()) {
+      cpy->tail(tail()->cloneFully(ctx));
+    }
+
+    return cpy;
+  }
+  
+  Compound_Selector* Compound_Selector::clone(Context& ctx) const
+  {
+    Compound_Selector* cpy = new (ctx.mem) Compound_Selector(*this);
+    return cpy;
+  }
+  
+
+
+  Selector_Placeholder* Selector::find_placeholder()
+  {
+    return 0;
+  }
+  
+  void Selector_List::adjust_after_pushing(Complex_Selector* c)
+  {
+    if (c->has_reference())   has_reference(true);
+    if (c->has_placeholder()) has_placeholder(true);
+
+#ifdef DEBUG
+    To_String to_string;
+    this->mCachedSelector(this->perform(&to_string));
+#endif
+  }
+
+  Selector_Placeholder* Selector_List::find_placeholder()
+  {
+    if (has_placeholder()) {
+      for (size_t i = 0, L = length(); i < L; ++i) {
+        if ((*this)[i]->has_placeholder()) return (*this)[i]->find_placeholder();
+      }
+    }
+    return 0;
+  }
+
+  Selector_Placeholder* Complex_Selector::find_placeholder()
+  {
+    if (has_placeholder()) {
+      if (head() && head()->has_placeholder()) return head()->find_placeholder();
+      else if (tail() && tail()->has_placeholder()) return tail()->find_placeholder();
+    }
+    return 0;
+  }
+
+  Selector_Placeholder* Compound_Selector::find_placeholder()
+  {
+    if (has_placeholder()) {
+      for (size_t i = 0, L = length(); i < L; ++i) {
+        if ((*this)[i]->has_placeholder()) return (*this)[i]->find_placeholder();
+      }
+      // return this;
+    }
+    return 0;
+  }
+
+  Selector_Placeholder* Selector_Placeholder::find_placeholder()
+  {
+    return this;
+  }
+
+  vector<string> Compound_Selector::to_str_vec()
+  {
+    To_String to_string;
+    vector<string> result;
+    result.reserve(length());
+    for (size_t i = 0, L = length(); i < L; ++i)
+    { result.push_back((*this)[i]->perform(&to_string)); }
+    return result;
+  }
+
+  Compound_Selector* Compound_Selector::minus(Compound_Selector* rhs, Context& ctx)
+  {
+    To_String to_string;
+    Compound_Selector* result = new (ctx.mem) Compound_Selector(path(), position());
+
+    // not very efficient because it needs to preserve order
+    for (size_t i = 0, L = length(); i < L; ++i)
+    {
+      bool found = false;
+      string thisSelector((*this)[i]->perform(&to_string));
+      for (size_t j = 0, M = rhs->length(); j < M; ++j)
+      {
+        if (thisSelector == (*rhs)[j]->perform(&to_string))
+        {
+          found = true;
+          break;
+        }
+      }
+      if (!found) (*result) << (*this)[i];
+    }
+
+    return result;
+  }
+  
+  void Compound_Selector::mergeSources(SourcesSet& sources, Context& ctx)
+  {
+    for (SourcesSet::iterator iterator = sources.begin(), endIterator = sources.end(); iterator != endIterator; ++iterator) {
+      this->sources_.insert((*iterator)->clone(ctx));
+    }
+  }
+
+  vector<Compound_Selector*> Complex_Selector::to_vector()
+  {
+    vector<Compound_Selector*> result;
+    Compound_Selector* h = head();
+    Complex_Selector* t = tail();
+    if (h) result.push_back(h);
+    while (t)
+    {
+      h = t->head();
+      t = t->tail();
+      if (h) result.push_back(h);
+    }
+    return result;
+  }
+
+}
+