sassc 0.0.1

data/ext/libsass/script/tap-runner

@@ -0,0 +1 @@
+$@ | tapout tap

data/ext/libsass/source_map.cpp

@@ -0,0 +1,133 @@
+#include "source_map.hpp"
+#include "json.hpp"
+
+#ifndef SASS_CONTEXT
+#include "context.hpp"
+#endif
+
+#include <string>
+#include <sstream>
+#include <cstddef>
+#include <iomanip>
+
+namespace Sass {
+  using std::ptrdiff_t;
+  SourceMap::SourceMap(const string& file) : current_position(Position(1, 1)), file(file) { }
+
+  string SourceMap::generate_source_map(Context &ctx) {
+
+    const bool include_sources = ctx.source_map_contents;
+    const vector<string> includes = ctx.include_links;
+    const vector<const char*> sources = ctx.sources;
+
+    JsonNode *json_srcmap = json_mkobject();
+
+    json_append_member(json_srcmap, "version", json_mknumber(3));
+
+    const char *include = file.c_str();
+    JsonNode *json_include = json_mkstring(include);
+    json_append_member(json_srcmap, "file", json_include);
+
+    JsonNode *json_includes = json_mkarray();
+    for (size_t i = 0; i < source_index.size(); ++i) {
+      const char *include = includes[source_index[i]].c_str();
+      JsonNode *json_include = json_mkstring(include);
+      json_append_element(json_includes, json_include);
+    }
+    json_append_member(json_srcmap, "sources", json_includes);
+
+    JsonNode *json_contents = json_mkarray();
+    if (include_sources) {
+      for (size_t i = 0; i < source_index.size(); ++i) {
+        const char *content = sources[source_index[i]];
+        JsonNode *json_content = json_mkstring(content);
+        json_append_element(json_contents, json_content);
+      }
+    }
+    json_append_member(json_srcmap, "sourcesContent", json_contents);
+
+    string mappings = serialize_mappings();
+    JsonNode *json_mappings = json_mkstring(mappings.c_str());
+    json_append_member(json_srcmap, "mappings", json_mappings);
+
+    JsonNode *json_names = json_mkarray();
+    // so far we have no implementation for names
+    // no problem as we do not alter any identifiers
+    json_append_member(json_srcmap, "names", json_names);
+
+    char *str = json_stringify(json_srcmap, "\t");
+    string result = string(str);
+    free(str);
+    json_delete(json_srcmap);
+    return result;
+  }
+
+  string SourceMap::serialize_mappings() {
+    string result = "";
+
+    size_t previous_generated_line = 0;
+    size_t previous_generated_column = 0;
+    size_t previous_original_line = 0;
+    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;
+
+      if (generated_line != previous_generated_line) {
+        previous_generated_column = 0;
+        if (generated_line > previous_generated_line) {
+          result += std::string(generated_line - previous_generated_line, ';');
+          previous_generated_line = generated_line;
+        }
+      }
+      else if (i > 0) {
+        result += ",";
+      }
+
+      // generated column
+      result += base64vlq.encode(static_cast<int>(generated_column) - static_cast<int>(previous_generated_column));
+      previous_generated_column = generated_column;
+      // file
+      result += base64vlq.encode(static_cast<int>(original_file) - static_cast<int>(previous_original_file));
+      previous_original_file = original_file;
+      // source line
+      result += base64vlq.encode(static_cast<int>(original_line) - static_cast<int>(previous_original_line));
+      previous_original_line = original_line;
+      // source column
+      result += base64vlq.encode(static_cast<int>(original_column) - static_cast<int>(previous_original_column));
+      previous_original_column = original_column;
+    }
+
+    return result;
+  }
+
+  void SourceMap::remove_line()
+  {
+    // prevent removing non existing lines
+    if (current_position.line > 1) {
+      current_position.line -= 1;
+      current_position.column = 1;
+    }
+  }
+
+  void SourceMap::update_column(const string& str)
+  {
+    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();
+    }
+  }
+
+  void SourceMap::add_mapping(AST_Node* node)
+  {
+    mappings.push_back(Mapping(node->position(), current_position));
+  }
+
+}

data/ext/libsass/source_map.hpp

@@ -0,0 +1,46 @@
+#define SASS_SOURCE_MAP
+
+#include <vector>
+
+#ifndef SASS_MAPPING
+#include "mapping.hpp"
+#endif
+
+#ifndef SASS_AST
+#include "ast.hpp"
+#endif
+
+#ifndef SASSS_BASE64VLQ
+#include "base64vlq.hpp"
+#endif
+
+
+
+namespace Sass {
+  using std::vector;
+
+  struct Context;
+
+  class SourceMap {
+
+  public:
+    vector<size_t> source_index;
+    SourceMap(const string& file);
+
+    void remove_line();
+    void update_column(const string& str);
+    void add_mapping(AST_Node* node);
+
+    string generate_source_map(Context &ctx);
+
+  private:
+
+    string serialize_mappings();
+
+    vector<Mapping> mappings;
+    Position current_position;
+    string file;
+    Base64VLQ base64vlq;
+  };
+
+}

data/ext/libsass/subset_map.hpp

@@ -0,0 +1,145 @@
+#define SASS_SUBSET_MAP
+
+#include <vector>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <sstream>
+
+// using namespace std;
+
+// template<typename T>
+// string vector_to_string(vector<T> v)
+// {
+//   stringstream buffer;
+//   buffer << "[";
+
+//   if (!v.empty())
+//   {  buffer << v[0]; }
+//   else
+//   { buffer << "]"; }
+
+//   if (v.size() == 1)
+//   { buffer << "]"; }
+//   else
+//   {
+//     for (size_t i = 1, S = v.size(); i < S; ++i) buffer << ", " << v[i];
+//     buffer << "]";
+//   }
+
+//   return buffer.str();
+// }
+
+// template<typename T>
+// string set_to_string(set<T> v)
+// {
+//   stringstream buffer;
+//   buffer << "[";
+//   typename set<T>::iterator i = v.begin();
+//   if (!v.empty())
+//   {  buffer << *i; }
+//   else
+//   { buffer << "]"; }
+
+//   if (v.size() == 1)
+//   { buffer << "]"; }
+//   else
+//   {
+//     for (++i; i != v.end(); ++i) buffer << ", " << *i;
+//     buffer << "]";
+//   }
+
+//   return buffer.str();
+// }
+
+namespace Sass {
+  using namespace std;
+
+  template<typename F, typename S, typename T>
+  struct triple {
+    F first;
+    S second;
+    T third;
+
+    triple(const F& f, const S& s, const T& t) : first(f), second(s), third(t) { }
+  };
+
+  template<typename F, typename S, typename T>
+  triple<F, S, T> make_triple(const F& f, const S& s, const T& t)
+  { return triple<F, S, T>(f, s, t); }
+
+  template<typename K, typename V>
+  class Subset_Map {
+  private:
+    vector<V> values_;
+    map<K, vector<triple<vector<K>, set<K>, size_t> > > hash_;
+  public:
+    void put(const vector<K>& s, const V& value);
+    vector<pair<V, vector<K> > > get_kv(const vector<K>& s);
+    vector<V> get_v(const vector<K>& s);
+    bool empty() { return values_.empty(); }
+    void clear() { values_.clear(); hash_.clear(); }
+  };
+
+  template<typename K, typename V>
+  void Subset_Map<K, V>::put(const vector<K>& s, const V& value)
+  {
+    if (s.empty()) throw "internal error: subset map keys may not be empty";
+    size_t index = values_.size();
+    values_.push_back(value);
+    set<K> ss;
+    for (size_t i = 0, S = s.size(); i < S; ++i)
+    { ss.insert(s[i]); }
+    for (size_t i = 0, S = s.size(); i < S; ++i)
+    {
+      hash_[s[i]];
+      hash_[s[i]].push_back(make_triple(s, ss, index));
+    }
+  }
+
+  template<typename K, typename V>
+  vector<pair<V, vector<K> > > Subset_Map<K, V>::get_kv(const vector<K>& s)
+  {
+    vector<K> sorted = s;
+    sort(sorted.begin(), sorted.end());
+    vector<pair<size_t, vector<K> > > indices;
+    for (size_t i = 0, S = s.size(); i < S; ++i) {
+      // cerr << "looking for " << s[i] << endl;
+      if (!hash_.count(s[i])) {
+        // cerr << "didn't find " << s[i] << endl;
+        continue;
+      }
+      vector<triple<vector<K>, set<K>, size_t> > subsets = hash_[s[i]];
+      // cerr << "length of subsets: " << subsets.size() << endl;
+      for (size_t j = 0, T = subsets.size(); j < T; ++j) {
+        if (!includes(sorted.begin(), sorted.end(), subsets[j].second.begin(), subsets[j].second.end())) {
+          // cout << vector_to_string(s) << " doesn't include " << set_to_string(subsets[j].second) << endl;
+          continue;
+        }
+        indices.push_back(make_pair(subsets[j].third, subsets[j].first));
+        // cerr << "pushed " << subsets[j].third << " and " << vector_to_string(subsets[j].first) << " onto indices" << endl;
+      }
+    }
+    sort(indices.begin(), indices.end());
+    typename vector<pair<size_t, vector<K> > >::iterator indices_end = unique(indices.begin(), indices.end());
+    indices.resize(distance(indices.begin(), indices_end));
+
+    vector<pair<V, vector<K> > > results;
+    for (size_t i = 0, S = indices.size(); i < S; ++i) {
+      results.push_back(make_pair(values_[indices[i].first], indices[i].second));
+    }
+    return results;
+  }
+
+  template<typename K, typename V>
+  vector<V> Subset_Map<K, V>::get_v(const vector<K>& s)
+  {
+    vector<pair<V, vector<K> > > kvs = get_kv(s);
+    vector<V> results;
+    for (size_t i = 0, S = kvs.size(); i < S; ++i) results.push_back(kvs[i].first);
+    return results;
+  }
+
+}

data/ext/libsass/support/libsass.pc.in

@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libsass
+URL: https://github.com/sass/libsass
+Description: A C implementation of a Sass compiler
+Version: @VERSION@
+Libs: -L${libdir} -lsass
+Cflags: -I${includedir}

data/ext/libsass/test-driver

@@ -0,0 +1,127 @@
+#! /bin/sh
+# test-driver - basic testsuite driver script.
+
+scriptversion=2012-06-27.10; # UTC
+
+# Copyright (C) 2011-2013 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+# Make unconditional expansion of undefined variables an error.  This
+# helps a lot in preventing typo-related bugs.
+set -u
+
+usage_error ()
+{
+  echo "$0: $*" >&2
+  print_usage >&2
+  exit 2
+}
+
+print_usage ()
+{
+  cat <<END
+Usage:
+  test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
+              [--expect-failure={yes|no}] [--color-tests={yes|no}]
+              [--enable-hard-errors={yes|no}] [--] TEST-SCRIPT
+The '--test-name', '--log-file' and '--trs-file' options are mandatory.
+END
+}
+
+# TODO: better error handling in option parsing (in particular, ensure
+# TODO: $log_file, $trs_file and $test_name are defined).
+test_name= # Used for reporting.
+log_file=  # Where to save the output of the test script.
+trs_file=  # Where to save the metadata of the test run.
+expect_failure=no
+color_tests=no
+enable_hard_errors=yes
+while test $# -gt 0; do
+  case $1 in
+  --help) print_usage; exit $?;;
+  --version) echo "test-driver $scriptversion"; exit $?;;
+  --test-name) test_name=$2; shift;;
+  --log-file) log_file=$2; shift;;
+  --trs-file) trs_file=$2; shift;;
+  --color-tests) color_tests=$2; shift;;
+  --expect-failure) expect_failure=$2; shift;;
+  --enable-hard-errors) enable_hard_errors=$2; shift;;
+  --) shift; break;;
+  -*) usage_error "invalid option: '$1'";;
+  esac
+  shift
+done
+
+if test $color_tests = yes; then
+  # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
+  red='' # Red.
+  grn='' # Green.
+  lgn='' # Light green.
+  blu='' # Blue.
+  mgn='' # Magenta.
+  std=''     # No color.
+else
+  red= grn= lgn= blu= mgn= std=
+fi
+
+do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
+trap "st=129; $do_exit" 1
+trap "st=130; $do_exit" 2
+trap "st=141; $do_exit" 13
+trap "st=143; $do_exit" 15
+
+# Test script is run here.
+"$@" >$log_file 2>&1
+estatus=$?
+if test $enable_hard_errors = no && test $estatus -eq 99; then
+  estatus=1
+fi
+
+case $estatus:$expect_failure in
+  0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
+  0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
+  77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
+  99:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
+  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
+  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
+esac
+
+# Report outcome to console.
+echo "${col}${res}${std}: $test_name"
+
+# Register the test result, and other relevant metadata.
+echo ":test-result: $res" > $trs_file
+echo ":global-test-result: $res" >> $trs_file
+echo ":recheck: $recheck" >> $trs_file
+echo ":copy-in-global-log: $gcopy" >> $trs_file
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End: