Add OutputStyle conversion and some tests

Author: bep

scss/common.go

@@ -11,6 +11,7 @@ package scss
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 )
 
 type (
@@ -24,6 +25,43 @@ const (
 	CompressedStyle
 )
 
+const (
+	nestedStyleStr     = "nested"
+	expandedStyleStr   = "expanded"
+	compactStyleStr    = "compact"
+	compressedStyleStr = "compressed"
+)
+
+var outputStyleFromString = map[string]OutputStyle{
+	nestedStyleStr:     NestedStyle,
+	expandedStyleStr:   ExpandedStyle,
+	compactStyleStr:    CompactStyle,
+	compressedStyleStr: CompressedStyle,
+}
+
+var outputStyleToString = map[OutputStyle]string{
+	NestedStyle:     nestedStyleStr,
+	ExpandedStyle:   expandedStyleStr,
+	CompactStyle:    compactStyleStr,
+	CompressedStyle: compressedStyleStr,
+}
+
+func OutputStyleFromString(style string) OutputStyle {
+	os, found := outputStyleFromString[strings.ToLower(style)]
+	if found {
+		return os
+	}
+	return NestedStyle
+}
+
+func OutputStyleToString(style OutputStyle) string {
+	os, found := outputStyleToString[style]
+	if found {
+		return os
+	}
+	return nestedStyleStr
+}
+
 type Options struct {
 	// Default is nested.
 	OutputStyle OutputStyle
@@ -41,6 +79,9 @@ type Options struct {
 	// Source map settings
 	SourceMapFilename       string
 	SourceMapRoot           string
+	InputPath               string
+	OutputPath              string
+	SourceMapContents       bool
 	OmitSourceMapURL        bool
 	EnableEmbeddedSourceMap bool
 }

scss/common_test.go

@@ -0,0 +1,30 @@
+// Copyright © 2018 Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+
+// Package scss provides options for SCSS transpilers. Note that there are no
+// current pure Go SASS implementation, so the only option is CGO and LibSASS.
+// But hopefully, fingers crossed, this will happen.
+package scss
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutputStyle(t *testing.T) {
+	assert := require.New(t)
+	assert.Equal(NestedStyle, OutputStyleFromString("nested"))
+	assert.Equal(ExpandedStyle, OutputStyleFromString("expanded"))
+	assert.Equal(CompactStyle, OutputStyleFromString("compact"))
+	assert.Equal(CompressedStyle, OutputStyleFromString("compressed"))
+	assert.Equal(NestedStyle, OutputStyleFromString("moo"))
+
+	assert.Equal("nested", OutputStyleToString(NestedStyle))
+	assert.Equal("expanded", OutputStyleToString(ExpandedStyle))
+	assert.Equal("compact", OutputStyleToString(CompactStyle))
+	assert.Equal("compressed", OutputStyleToString(CompressedStyle))
+	assert.Equal("nested", OutputStyleToString(43))
+}

scss/libsass/transpiler.go

@@ -17,36 +17,38 @@ import (
 	"github.com/wellington/go-libsass/libs"
 )
 
-var _ tocss.Transpiler = (*libsassTranspiler)(nil)
-
 type libsassTranspiler struct {
 	options scss.Options
 }
 
-func New(options scss.Options) (*libsassTranspiler, error) {
+// New creates a new libsass transpiler configured with the given options.
+func New(options scss.Options) (tocss.Transpiler, error) {
 	return &libsassTranspiler{options: options}, nil
 }
 
-func (t *libsassTranspiler) Execute(dst io.Writer, src io.Reader) error {
-	// TODO(bep) basepath
+// Execute transpiles the SCSS from src into dst. Note that you can import
+// older SASS (.sass) files, but the main entry (src) currently needs to be SCSS.
+func (t *libsassTranspiler) Execute(dst io.Writer, src io.Reader) (tocss.Result, error) {
+	var result tocss.Result
 
 	b, err := ioutil.ReadAll(src)
 	if err != nil {
-		return err
+		return result, err
 	}
 	sourceStr := string(b)
 
 	dataCtx := libs.SassMakeDataContext(sourceStr)
-	opts := libs.SassDataContextGetOptions(dataCtx)
 
-	if t.options.ImportResolver != nil {
-		idx := libs.BindImporter(opts, t.options.ImportResolver)
-		defer libs.RemoveImporter(idx)
-	}
+	opts := libs.SassDataContextGetOptions(dataCtx)
 
 	{
-
 		// Set options
+
+		if t.options.ImportResolver != nil {
+			idx := libs.BindImporter(opts, t.options.ImportResolver)
+			defer libs.RemoveImporter(idx)
+		}
+
 		if t.options.Precision != 0 {
 			libs.SassOptionSetPrecision(opts, t.options.Precision)
 		}
@@ -59,6 +61,14 @@ func (t *libsassTranspiler) Execute(dst io.Writer, src io.Reader) error {
 			libs.SassOptionSetSourceMapRoot(opts, t.options.SourceMapRoot)
 		}
 
+		if t.options.OutputPath != "" {
+			libs.SassOptionSetOutputPath(opts, t.options.OutputPath)
+		}
+		if t.options.InputPath != "" {
+			libs.SassOptionSetInputPath(opts, t.options.InputPath)
+		}
+
+		libs.SassOptionSetSourceMapContents(opts, t.options.SourceMapContents)
 		libs.SassOptionSetOmitSourceMapURL(opts, t.options.OmitSourceMapURL)
 		libs.SassOptionSetSourceMapEmbed(opts, t.options.EnableEmbeddedSourceMap)
 		libs.SassOptionSetIncludePath(opts, strings.Join(t.options.IncludePaths, string(os.PathListSeparator)))
@@ -73,18 +83,18 @@ func (t *libsassTranspiler) Execute(dst io.Writer, src io.Reader) error {
 	libs.SassCompilerParse(compiler)
 	libs.SassCompilerExecute(compiler)
 
-	libs.SassOptionSetSourceMapEmbed(opts, t.options.EnableEmbeddedSourceMap)
-	libs.SassOptionSetSourceMapContents(opts, true)
-
 	defer libs.SassDeleteCompiler(compiler)
 
-	result := libs.SassContextGetOutputString(ctx)
+	outputString := libs.SassContextGetOutputString(ctx)
 
-	io.WriteString(dst, result)
+	io.WriteString(dst, outputString)
 
 	if status := libs.SassContextGetErrorStatus(ctx); status != 0 {
-		return scss.JSONToError(libs.SassContextGetErrorJSON(ctx))
+		return result, scss.JSONToError(libs.SassContextGetErrorJSON(ctx))
 	}
 
-	return nil
+	result.SourceMapFilename = libs.SassOptionGetSourceMapFile(opts)
+	result.SourceMapContent = libs.SassContextGetSourceMapString(ctx)
+
+	return result, nil
 }

scss/libsass/transpiler_test.go

@@ -7,6 +7,9 @@ package libsass
 
 import (
 	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"sync"
 	"testing"
 
@@ -33,7 +36,8 @@ div { p { color: $white; } }`)
 	transpiler, err := New(scss.Options{ImportResolver: importResolver})
 	assert.NoError(err)
 
-	assert.NoError(transpiler.Execute(&dst, src))
+	_, err = transpiler.Execute(&dst, src)
+	assert.NoError(err)
 	assert.Equal("div p {\n  color: #fff; }\n", dst.String())
 }
 
@@ -47,10 +51,51 @@ div { p { color: #ccc; } }`)
 	transpiler, err := New(scss.Options{OutputStyle: scss.CompressedStyle})
 	assert.NoError(err)
 
-	assert.NoError(transpiler.Execute(&dst, src))
+	_, err = transpiler.Execute(&dst, src)
+	assert.NoError(err)
 	assert.Equal("div p{color:#ccc}\n", dst.String())
 }
 
+func TestSourceMapSettings(t *testing.T) {
+	dir, _ := ioutil.TempDir(os.TempDir(), "tocss")
+	defer os.RemoveAll(dir)
+
+	colors := filepath.Join(dir, "_colors.scss")
+
+	ioutil.WriteFile(colors, []byte(`
+$moo:       #f442d1 !default;
+`), 0755)
+
+	assert := require.New(t)
+	src := bytes.NewBufferString(`
+@import "colors";
+
+div { p { color: $moo; } }`)
+
+	var dst bytes.Buffer
+
+	transpiler, err := New(scss.Options{
+		IncludePaths:            []string{dir},
+		EnableEmbeddedSourceMap: false,
+		SourceMapContents:       true,
+		OmitSourceMapURL:        false,
+		SourceMapFilename:       "source.map",
+		OutputPath:              "outout.css",
+		InputPath:               "input.scss",
+		SourceMapRoot:           "/my/root",
+	})
+	assert.NoError(err)
+
+	result, err := transpiler.Execute(&dst, src)
+	assert.NoError(err)
+	assert.Equal("div p {\n  color: #f442d1; }\n\n/*# sourceMappingURL=source.map */", dst.String())
+	assert.Equal("source.map", result.SourceMapFilename)
+	assert.Contains(result.SourceMapContent, `"sourceRoot": "/my/root",`)
+	assert.Contains(result.SourceMapContent, `"file": "outout.css",`)
+	assert.Contains(result.SourceMapContent, `"input.scss",`)
+	assert.Contains(result.SourceMapContent, `mappings": "AAGA,AAAM,GAAH,CAAG,CAAC,CAAC;EAAE,KAAK,ECFH,OAAO,GDEM"`)
+}
+
 func TestConcurrentTranspile(t *testing.T) {
 
 	assert := require.New(t)
@@ -77,7 +122,8 @@ func TestConcurrentTranspile(t *testing.T) {
 
 div { p { color: $white; } }`)
 				var dst bytes.Buffer
-				assert.NoError(transpiler.Execute(&dst, src))
+				_, err := transpiler.Execute(&dst, src)
+				assert.NoError(err)
 				assert.Equal("div p{color:#fff}\n", dst.String())
 			}
 		}()
@@ -101,19 +147,11 @@ func BenchmarkTranspile(b *testing.B) {
 		src.Reset()
 		dst.Reset()
 		src.WriteString(srcs)
-		if err := transpiler.Execute(&dst, &src); err != nil {
+		if _, err := transpiler.Execute(&dst, &src); err != nil {
 			b.Fatal(err)
 		}
 		if dst.String() != "div p{color:#ccc}\n" {
 			b.Fatal("Got:", dst.String())
 		}
 	}
 }
-
-// Options (tests)
-// SASS
-// SCSS
-// Preserve comments
-// Style (compressed?)
-// Basic benchmark
-// Multi threaded

tocss/transpiler.go

@@ -11,6 +11,12 @@ import (
 	"io"
 )
 
+type Result struct {
+	// If source maps are configured.
+	SourceMapFilename string
+	SourceMapContent  string
+}
+
 type Transpiler interface {
-	Execute(dst io.Writer, src io.Reader) error
+	Execute(dst io.Writer, src io.Reader) (Result, error)
 }