sass-embedded 0.2.3 → 0.4.2

data/test/{custom_importer_test.rb → importer_test.rb}

@@ -3,7 +3,7 @@
 require_relative 'test_helper'
 
 module Sass
-  class CustomImporterTest < MiniTest::Test
+  class ImporterTest < MiniTest::Test
     include TempFileTest
 
     def setup
@@ -15,7 +15,7 @@ module Sass
     end
 
     def render(data, importer)
-      @embedded.render({ data: data, importer: importer })[:css]
+      @embedded.render(data: data, importer: importer)[:css]
     end
 
     def test_custom_importer_works
@@ -86,17 +86,16 @@ module Sass
     end
 
     def test_custom_importer_that_does_not_resolve
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
-                   return nil
                  }
                ])
       end
     end
 
     def test_custom_importer_that_returns_error
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
                    IOError.new 'test error'
@@ -106,7 +105,7 @@ module Sass
     end
 
     def test_custom_importer_that_raises_error
-      assert_raises(CompilationError) do
+      assert_raises(RenderError) do
         render("@import 'test.scss';", [
                  lambda { |_url, _prev|
                    raise IOError, 'test error'
@@ -116,15 +115,13 @@ module Sass
     end
 
     def test_parent_path_is_accessible
-      output = @embedded.render({
-                                  data: "@import 'parent.scss';",
-                                  file: 'import-parent-filename.scss',
-                                  importer: [
-                                    lambda { |_url, prev|
-                                      { contents: ".#{prev} { color: red; }" }
-                                    }
-                                  ]
-                                })[:css]
+      output = @embedded.render(data: "@import 'parent.scss';",
+                                file: 'import-parent-filename.scss',
+                                importer: [
+                                  lambda { |_url, prev|
+                                    { contents: ".#{prev} { color: red; }" }
+                                  }
+                                ])[:css]
 
       assert_equal <<~CSS.chomp, output
         .import-parent-filename.scss {
@@ -134,23 +131,19 @@ module Sass
     end
 
     def test_call_embedded_importer
-      output = @embedded.render({
-                                  data: "@import 'parent.scss';",
-                                  importer: [
-                                    lambda { |_url, _prev|
-                                      {
-                                        contents: @embedded.render({
-                                                                     data: "@import 'parent-parent.scss'",
-                                                                     importer: [
-                                                                       lambda { |_url, _prev|
-                                                                         { contents: 'h1 { color: black; }' }
-                                                                       }
-                                                                     ]
-                                                                   })[:css]
-                                      }
+      output = @embedded.render(data: "@import 'parent.scss';",
+                                importer: [
+                                  lambda { |_url, _prev|
+                                    {
+                                      contents: @embedded.render(data: "@import 'parent-parent.scss'",
+                                                                 importer: [
+                                                                   lambda { |_url, _prev|
+                                                                     { contents: 'h1 { color: black; }' }
+                                                                   }
+                                                                 ])[:css]
                                     }
-                                  ]
-                                })[:css]
+                                  }
+                                ])[:css]
 
       assert_equal <<~CSS.chomp, output
         h1 {

data/test/include_paths_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class IncludePathsTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_include_paths
+      temp_dir('included_1')
+      temp_dir('included_2')
+
+      temp_file('included_1/import_parent.scss', '$s: 30px;')
+      temp_file('included_2/import.scss', "@use 'import_parent' as *; $size: $s;")
+      temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
+
+      css = <<~CSS.chomp
+        .hi {
+          width: 30px;
+        }
+      CSS
+
+      assert_equal css, @embedded.render(file: 'styles.scss',
+                                         include_paths: %w[
+                                           included_1 included_2
+                                         ])[:css]
+    end
+
+    def test_global_include_paths
+      temp_dir('included_1')
+      temp_dir('included_2')
+
+      temp_file('included_1/import_parent.scss', '$s: 30px;')
+      temp_file('included_2/import.scss', "@use 'import_parent' as *; $size: $s;")
+      temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
+
+      ::Sass.include_paths << 'included_1'
+      ::Sass.include_paths << 'included_2'
+
+      css = <<~CSS.chomp
+        .hi {
+          width: 30px;
+        }
+      CSS
+
+      assert_equal css, @embedded.render(file: 'styles.scss')[:css]
+    end
+
+    def test_include_paths_from_env
+      expected_include_paths = %w[included_3 included_4]
+
+      ::Sass.instance_eval { @include_paths = nil }
+
+      ENV['SASS_PATH'] = expected_include_paths.join(File::PATH_SEPARATOR)
+
+      assert_equal expected_include_paths, ::Sass.include_paths
+
+      ::Sass.include_paths.clear
+    end
+
+    def test_include_paths_not_configured
+      temp_dir('included_5')
+      temp_dir('included_6')
+      temp_file('included_5/import_parent.scss', '$s: 30px;')
+      temp_file('included_6/import.scss', "@use 'import_parent' as *; $size: $s;")
+      temp_file('styles.scss', "@use 'import.scss' as *; .hi { width: $size; }")
+
+      assert_raises(RenderError) do
+        @embedded.render(file: 'styles.scss')
+      end
+    end
+  end
+end

data/test/indented_syntax_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class IndentedSyntaxTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_input_data_with_indented_syntax
+      sass = <<~SASS
+        $size: 30px
+        .foo
+          width: $size
+      SASS
+
+      css = <<~CSS.chomp
+        .foo {
+          width: 30px;
+        }
+      CSS
+
+      assert_raises(RenderError) do
+        @embedded.render(data: sass)
+      end
+
+      assert_raises(RenderError) do
+        @embedded.render(data: sass, indented_syntax: false)
+      end
+
+      assert_equal css, @embedded.render(data: sass, indented_syntax: true)[:css]
+    end
+
+    def test_input_file_with_indented_syntax
+      sass = <<~SASS
+        $size: 30px
+        .foo
+          width: $size
+      SASS
+
+      css = <<~CSS.chomp
+        .foo {
+          width: 30px;
+        }
+      CSS
+
+      temp_file('style.sass', sass)
+
+      assert_equal css, @embedded.render(file: 'style.sass')[:css]
+      assert_equal css, @embedded.render(file: 'style.sass', indented_syntax: true)[:css]
+      assert_equal css, @embedded.render(file: 'style.sass', indented_syntax: false)[:css]
+    end
+  end
+end

data/test/input_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class InputTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_input_data
+      scss = <<~SCSS
+        $var: bang;
+
+        .foo {
+          baz: $var;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        .foo {
+          baz: bang;
+        }
+      CSS
+
+      result = @embedded.render(data: scss)
+      assert_equal css, result[:css]
+    end
+
+    def test_input_file
+      scss = <<~SCSS
+        $var: bang;
+
+        .foo {
+          baz: $var;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        .foo {
+          baz: bang;
+        }
+      CSS
+
+      temp_file('style.scss', scss)
+      result = @embedded.render(file: 'style.scss')
+      assert_equal css, result[:css]
+    end
+  end
+end

data/test/output_test.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class OutputTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_output_output_style
+      data = <<~SCSS
+        $var: bang;
+
+        .foo {
+          baz: $var;
+        }
+      SCSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: data, output_style: :expanded)[:css]
+        .foo {
+          baz: bang;
+        }
+      CSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: data, output_style: :compressed)[:css]
+        .foo{baz:bang}
+      CSS
+
+      assert_raises(ArgumentError) do
+        @embedded.render(data: data, output_style: :nested)[:css]
+      end
+
+      assert_raises(ArgumentError) do
+        @embedded.render(data: data, output_style: :compact)[:css]
+      end
+
+      assert_raises(ArgumentError) do
+        @embedded.render(data: data, output_style: nil)[:css]
+      end
+    end
+
+    DATA_INDENT_TEST = <<~SCSS
+      @media all {
+        .foo {
+          baz: bang;
+        }
+      }
+    SCSS
+
+    def test_output_indent_width
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_width: 0)[:css]
+        @media all {
+        .foo {
+        baz: bang;
+        }
+        }
+      CSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_width: 1)[:css]
+        @media all {
+         .foo {
+          baz: bang;
+         }
+        }
+      CSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_width: 4)[:css]
+        @media all {
+            .foo {
+                baz: bang;
+            }
+        }
+      CSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_width: 10)[:css]
+        @media all {
+                  .foo {
+                            baz: bang;
+                  }
+        }
+      CSS
+
+      assert_raises(RangeError) do
+        @embedded.render(data: DATA_INDENT_TEST, indent_width: -1)[:css]
+      end
+
+      assert_raises(RangeError) do
+        @embedded.render(data: DATA_INDENT_TEST, indent_width: 11)[:css]
+      end
+
+      assert_raises(ArgumentError) do
+        @embedded.render(data: DATA_INDENT_TEST, indent_width: 3.14)[:css]
+      end
+    end
+
+    def test_output_indent_type
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_type: :tab)[:css]
+        @media all {
+        \t\t.foo {
+        \t\t\t\tbaz: bang;
+        \t\t}
+        }
+      CSS
+
+      assert_equal <<~CSS.chomp, @embedded.render(data: DATA_INDENT_TEST, indent_width: 1, indent_type: 'tab')[:css]
+        @media all {
+        \t.foo {
+        \t\tbaz: bang;
+        \t}
+        }
+      CSS
+    end
+
+    def test_output_linefeed
+      data = <<~SCSS
+        $var: bang;
+
+        .foo {
+          baz: $var;
+        }
+      SCSS
+
+      assert_equal ".foo {\n  baz: bang;\n}", @embedded.render(data: data, linefeed: :lf)[:css]
+      assert_equal ".foo {\n\r  baz: bang;\n\r}", @embedded.render(data: data, linefeed: :lfcr)[:css]
+      assert_equal ".foo {\r  baz: bang;\r}", @embedded.render(data: data, linefeed: :cr)[:css]
+      assert_equal ".foo {\r\n  baz: bang;\r\n}", @embedded.render(data: data, linefeed: :crlf)[:css]
+    end
+  end
+end

data/test/render_error_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class RenderErrorTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_first_backtrace_is_stdin
+      template = <<~SCSS
+        .foo {
+          baz: bang;
+          padding top: 10px;
+        }
+      SCSS
+
+      @embedded.render(data: template)
+    rescue RenderError => e
+      expected = 'stdin:3:20'
+      assert_equal expected, e.backtrace.first
+    end
+
+    def test_first_backtrace_is_file
+      temp_file('style.scss', <<~SCSS)
+        .foo {
+          baz: bang;
+          padding top: 10px;
+        }
+      SCSS
+
+      @embedded.render(file: 'style.scss')
+    rescue RenderError => e
+      assert e.backtrace.first.end_with? '/style.scss:3:20'
+    end
+  end
+end