Initial commit

Author: dahlia

.gitignore

@@ -9,3 +9,9 @@ build/*
 a.out
 bin/*
 *.gem
+
+dist/
+.*.swp
+*.egg
+*.egg-info
+*.so

MANIFEST.in

@@ -0,0 +1,3 @@
+include *.h
+include *.hpp
+include *.cpp

sass.c

@@ -0,0 +1,216 @@
+#include <Python.h>
+#include "sass_interface.h"
+
+typedef struct {
+    PyObject_HEAD
+    struct sass_options options;
+} sass_OptionsObject;
+
+static int
+sass_Options_init(sass_OptionsObject *self, PyObject *args, PyObject *kwds) {
+    static char *sig[] = {"include_paths", "image_path", NULL};
+    PyObject *include_paths, *image_path, *item;
+    char *include_paths_cstr, *item_buffer, *image_path_cstr;
+    size_t include_paths_len, include_paths_size, i, offset, item_size,
+           image_path_size;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OS", sig,
+                                     &include_paths, &image_path)) {
+        return -1;
+    }
+
+    self->options.output_style = SASS_STYLE_NESTED;
+
+    if (include_paths == Py_None) {
+        PyErr_SetString(PyExc_TypeError, "include_paths must not be None");
+        return -1;
+    }
+    if (PyString_Check(include_paths)) {
+        if (PyString_AsStringAndSize(include_paths,
+                                     &include_paths_cstr, &include_paths_size)
+            != 0) {
+            return -1;
+        }
+        self->options.include_paths = malloc(sizeof(char) *
+                                             (include_paths_size + 1));
+        strncpy(self->options.include_paths,
+                include_paths_cstr,
+                include_paths_size + 1);
+        self->options.include_paths[include_paths_size] = '\0';
+    }
+    else if (PySequence_Check(include_paths)) {
+        include_paths_len = PySequence_Size(include_paths);
+        if (include_paths_len < 0) {
+            return -1;
+        }
+        include_paths_size = 0;
+        for (i = 0; i < include_paths_len; ++i) {
+            item = PySequence_GetItem(include_paths, i);
+            if (item == NULL) {
+                return -1;
+            }
+            if (!PyString_Check(item)) {
+                PyErr_Format(PyExc_TypeError,
+                             "include_paths must consists of only strings, "
+                             "but #%d is not a string", i);
+                return -1;
+            }
+            include_paths_size += PyString_Size(item);
+        }
+        // add glue chars
+        if (include_paths_len > 1) {
+            include_paths_size += include_paths_len - 1;
+        }
+        self->options.include_paths = malloc(sizeof(char) *
+                                             (include_paths_size + 1));
+        // join
+        offset = 0;
+        for (i = 0; i < include_paths_len; ++i) {
+            if (i) {
+                self->options.include_paths[offset] = ':';
+                ++offset;
+            }
+            item = PySequence_GetItem(include_paths, i);
+            PyString_AsStringAndSize(item, &item_buffer, &item_size);
+            strncpy(self->options.include_paths + offset,
+                    item_buffer, item_size);
+            offset += item_size;
+        }
+        self->options.include_paths[include_paths_size] = '\0';
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "include_paths must be a string or a sequence of "
+                        "strings");
+        return -1;
+    }
+
+    if (PyString_AsStringAndSize(image_path,
+                                 &image_path_cstr, &image_path_size) != 0) {
+        return -1;
+    }
+    self->options.image_path = malloc(sizeof(char) * (image_path_size + 1));
+    strncpy(self->options.image_path, image_path_cstr, image_path_size + 1);
+    self->options.image_path[image_path_size] = '\0';
+
+    return 0;
+}
+
+static void
+sass_Options_dealloc(sass_OptionsObject *self) {
+    free(self->options.include_paths);
+    free(self->options.image_path);
+    self->ob_type->tp_free((PyObject *) self);
+}
+
+static PyObject *
+sass_Options_get_include_paths(sass_OptionsObject *self, void *closure)
+{
+    size_t i, j;
+    char *paths;
+    PyObject *list;
+    int tmp;
+
+    paths = self->options.include_paths;
+    list = PyList_New(0);
+    if (list == NULL) {
+        return NULL;
+    }
+    Py_INCREF(list);
+
+    i = j = 0;
+    do {
+        if (i > j && (paths[i] == ':' || paths[i] == '\0')) {
+            tmp = PyList_Append(list,
+                                PyString_FromStringAndSize(paths + j, i - j));
+            if (tmp != 0) {
+                return NULL;
+            }
+            j = i + 1;
+        }
+    }
+    while (paths[i++]);
+
+    return list;
+}
+
+static PyObject *
+sass_Options_get_image_path(sass_OptionsObject *self, void *closure)
+{
+    PyObject *string;
+    string = PyString_FromString(self->options.image_path);
+    Py_INCREF(string);
+    return string;
+}
+
+static PyGetSetDef sass_Options_getset[] = {
+    {"include_paths", (getter) sass_Options_get_include_paths, NULL,
+     "The list of paths to include."},
+    {"image_path", (getter) sass_Options_get_image_path, NULL,
+     "The path to find images."},
+    {NULL}
+};
+
+static PyTypeObject sass_OptionsType = {
+    PyObject_HEAD_INIT(NULL)
+    .ob_size = 0,
+    .tp_name = "sass.Options",
+    .tp_basicsize = sizeof(sass_OptionsObject),
+    .tp_itemsize = 0,
+    .tp_dealloc = (destructor) sass_Options_dealloc,
+    .tp_print = 0,
+    .tp_getattr = 0,
+    .tp_setattr = 0,
+    .tp_compare = 0,
+    .tp_repr = 0,
+    .tp_as_number = 0,
+    .tp_as_sequence = 0,
+    .tp_as_mapping = 0,
+    .tp_hash = 0,
+    .tp_call = 0,
+    .tp_str = 0,
+    .tp_getattro = 0,
+    .tp_setattro = 0,
+    .tp_as_buffer = 0,
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_doc = "The object which contains compilation options.",
+    .tp_traverse = 0,
+    .tp_clear = 0,
+    .tp_richcompare = 0,
+    .tp_weaklistoffset = 0,
+    .tp_iter = 0,
+    .tp_iternext = 0,
+    .tp_methods = 0,
+    .tp_members = 0,
+    .tp_getset = sass_Options_getset,
+    .tp_base = 0,
+    .tp_dict = 0,
+    .tp_descr_get = 0,
+    .tp_descr_set = 0,
+    .tp_dictoffset = 0,
+    .tp_init = (initproc) sass_Options_init,
+    .tp_alloc = 0,
+    .tp_new = 0
+};
+
+static PyMethodDef sass_methods[] = {
+    {NULL}
+};
+
+PyMODINIT_FUNC
+initsass()
+{
+    PyObject *module;
+
+    sass_OptionsType.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&sass_OptionsType) < 0) {
+        return;
+    }
+
+    module = Py_InitModule3("sass", sass_methods,
+                            "The thin binding of libsass for Python.");
+    if (module == NULL) {
+        return;
+    }
+    Py_INCREF(&sass_OptionsType);
+    PyModule_AddObject(module, "Options", (PyObject *) &sass_OptionsType);
+}

sasstests.py

@@ -0,0 +1,32 @@
+from attest import Tests, assert_hook, raises
+
+from sass import Options
+
+
+suite = Tests()
+
+
+@suite.test
+def options_include_paths():
+    o = Options(include_paths='ab/cd:de/fg', image_path='')
+    assert o.include_paths == ['ab/cd', 'de/fg']
+    o = Options(include_paths=['li/st', 'te/st'], image_path='')
+    assert o.include_paths == ['li/st', 'te/st']
+    o = Options(include_paths=('tup/le', 'te/st'), image_path='')
+    assert o.include_paths == ['tup/le', 'te/st']
+    with raises(TypeError):
+        Options(include_paths=None, image_path='a/b')
+    with raises(TypeError):
+        Options(include_paths=123, image_path='a/b')
+
+
+@suite.test
+def options_image_path():
+    o = Options(include_paths='a:b', image_path='image/path')
+    assert o.image_path == 'image/path'
+    with raises(TypeError):
+        Options(include_paths='a:b', image_path=None)
+    with raises(TypeError):
+        Options(include_paths='a:b', image_path=123)
+    with raises(TypeError):
+        Options(include_paths='a:b', image_path=['a/b', 'c/d'])

setup.py

@@ -0,0 +1,41 @@
+try:
+    from setuptools import Extension, setup
+except ImportError:
+    from distutils.core import Extension, setup
+
+
+libsass_sources = [ 
+    'context.cpp', 'functions.cpp', 'document.cpp',
+    'document_parser.cpp', 'eval_apply.cpp', 'node.cpp',
+    'node_factory.cpp', 'node_emitters.cpp', 'prelexer.cpp',
+    'sass_interface.cpp',
+]
+
+libsass_headers = [
+    'color_names.hpp', 'error.hpp', 'node.hpp',
+    'context.hpp', 'eval_apply.hpp', 'node_factory.hpp',
+    'document.hpp', 'functions.hpp', 'prelexer.hpp',
+    'sass_interface.h'
+]
+
+sass_extension = Extension(
+    'sass',
+    ['sass.c'] + libsass_sources,
+    depends=libsass_headers,
+    extra_compile_args=['-c', '-Wall', '-O2', '-fPIC'],
+    extra_link_args=['-fPIC'],
+)
+
+setup(
+    name='libsass',
+    version='0.1.0',
+    ext_modules=[sass_extension],
+    py_modules=['sasstests'],
+    license='MIT License',
+    author='Hong Minhee',
+    author_email='minhee' '@' 'dahlia.kr',
+    url='https://github.com/dahlia/libsass-python',
+    tests_require=['Attest'],
+    test_loader='attest:auto_reporter.test_loader',
+    test_suite='sasstests.suite'
+)