sass-embedded 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e03d2c1775fdd10b7f9d2b21898ac0a6e31e0be96157139742384c7be9b4275a
-  data.tar.gz: dacdc9589a8da93246b791794f97be2c8818f8a492d77e473c9fa543fd49db9e
+  metadata.gz: c9afb73da6288ecf0360685cc9ddb4c072eb8840da50acaa8a52b67f09998e6c
+  data.tar.gz: 1a20d885e2e9f55ffd861f9428499f4c3bdea64a4aea81e44f356af8be69eccc
 SHA512:
-  metadata.gz: 3be32cd37a7078fceabd16c661cf985fdfc1aa31fbf8b88e6c768cb8edd57749a30e28a77f367d6cc8c6c505710f402e1970ae6c12210b3f46fc10a42cf8d81d
-  data.tar.gz: 5a122cd7c2e883f28b9401ce70d8fb43fcfcf39e1ff64484f5bf036c6978ca1a01cf8d69b1ebbf22f0fde81f98272127cf5a96d381b0279028d316d90775ebfb
+  metadata.gz: 679cfc5b502de2fdc5b33c8117b7e1d68f94acd62c7afbe04ebb17f9bceacdc677e8b35197cf239f92fed4e3d523468d71798d899c360d8402be127bdb50ac48
+  data.tar.gz: e1d698b3980914299ee2ce570bd1f109a875859c147f8930366df8e2dabcae94f0e0795339f6614f3f7828e365c191ba24554e30869e4bd106f565f1cbbb9af2

data/lib/sass/embedded.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'base64'
+
 module Sass
   # The interface for using dart-sass-embedded
   class Embedded
@@ -9,30 +12,36 @@ module Sass
       @id = 0
     end
 
-    # rubocop:disable Lint/UnusedMethodArgument
+    def info
+      @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(
+        id: next_id
+      )
+    end
 
     def render(data: nil,
                file: nil,
                indented_syntax: false,
                include_paths: [],
                output_style: :expanded,
-               precision: 5,
+               # precision: 5,
                indent_type: :space,
                indent_width: 2,
                linefeed: :lf,
-               source_comments: false,
+               # source_comments: false,
                source_map: false,
                out_file: nil,
                omit_source_map_url: false,
-               source_map_contents: false,
+               # source_map_contents: false,
                source_map_embed: false,
                source_map_root: '',
                functions: {},
                importer: [])
-      # rubocop:enable Lint/UnusedMethodArgument
-
       start = Util.now
 
+      indent_type = parse_indent_type(indent_type)
+      indent_width = parse_indent_width(indent_width)
+      linefeed = parse_linefeed(linefeed)
+
       compilation_id = next_id
 
       renderer = Renderer.new(
@@ -70,8 +79,10 @@ module Sass
         raise RenderError.new(
           response.failure.message,
           response.failure.formatted,
-          if response.failure.span
-            response.failure.span.url == '' ? 'stdin' : URI.parse(response.failure.span.url).path
+          if response.failure.span&.url == ''
+            'stdin'
+          else
+            Util.path(response.failure.span.url)
           end,
           response.failure.span ? response.failure.span.start.line + 1 : nil,
           response.failure.span ? response.failure.span.start.column + 1 : nil,
@@ -79,11 +90,27 @@ module Sass
         )
       end
 
+      map, source_map = post_process_map(map: response.success.source_map,
+                                         file: file,
+                                         out_file: out_file,
+                                         source_map: source_map,
+                                         source_map_root: source_map_root)
+
+      css = post_process_css(css: response.success.css,
+                             indent_type: indent_type,
+                             indent_width: indent_width,
+                             linefeed: linefeed,
+                             map: map,
+                             out_file: out_file,
+                             omit_source_map_url: omit_source_map_url,
+                             source_map: source_map,
+                             source_map_embed: source_map_embed)
+
       finish = Util.now
 
       {
-        css: response.success.css,
-        map: response.success.source_map,
+        css: css,
+        map: map,
         stats: {
           entry: file.nil? ? 'data' : file,
           start: start,
@@ -100,16 +127,108 @@ module Sass
 
     private
 
-    def info
-      version_response = @transport.send EmbeddedProtocol::InboundMessage::VersionRequest.new(
-        id: next_id
-      )
-      {
-        compiler_version: version_response.compiler_version,
-        protocol_version: version_response.protocol_version,
-        implementation_name: version_response.implementation_name,
-        implementation_version: version_response.implementation_version
-      }
+    def post_process_map(map:,
+                         file:,
+                         out_file:,
+                         source_map:,
+                         source_map_root:)
+      return if map.nil? || map.empty?
+
+      map_data = JSON.parse(map)
+
+      map_data['sourceRoot'] = source_map_root
+
+      source_map_path = if source_map.is_a? String
+                          source_map
+                        else
+                          "#{out_file}.map"
+                        end
+
+      source_map_dir = File.dirname(source_map_path)
+
+      if out_file
+        map_data['file'] = Util.relative(source_map_dir, out_file)
+      elsif file
+        ext = File.extname(file)
+        map_data['file'] = "#{file[0..(ext.empty? ? -1 : -ext.length - 1)]}.css"
+      else
+        map_data['file'] = 'stdin.css'
+      end
+
+      map_data['sources'].map! do |source|
+        if source.start_with? Util::FILE_PROTOCOL
+          Util.relative(source_map_dir, Util.path(source))
+        else
+          source
+        end
+      end
+
+      [-JSON.generate(map_data), source_map_path]
+    end
+
+    def post_process_css(css:,
+                         indent_type:,
+                         indent_width:,
+                         linefeed:,
+                         map:,
+                         omit_source_map_url:,
+                         out_file:,
+                         source_map:,
+                         source_map_embed:)
+      css = +css
+      if indent_width != 2 || indent_type.to_sym != :space
+        indent = indent_type * indent_width
+        css.gsub!(/^ +/) do |space|
+          indent * (space.length / 2)
+        end
+      end
+      css.gsub!("\n", linefeed) if linefeed != "\n"
+
+      unless map.nil? || omit_source_map_url == true
+        url = if source_map_embed
+                "data:application/json;base64,#{Base64.strict_encode64(map)}"
+              elsif out_file
+                Util.relative(File.dirname(out_file), source_map)
+              else
+                source_map
+              end
+        css += "#{linefeed}/*# sourceMappingURL=#{url} */"
+      end
+
+      -css
+    end
+
+    def parse_indent_type(indent_type)
+      case indent_type.to_sym
+      when :space
+        ' '
+      when :tab
+        "\t"
+      else
+        raise ArgumentError, 'indent_type must be :space or :tab'
+      end
+    end
+
+    def parse_indent_width(indent_width)
+      raise ArgumentError, 'indent_width must be an integer' unless indent_width.is_a? Integer
+      raise RangeError, 'indent_width must be in between 0 and 10 (inclusive)' unless indent_width.between? 0, 10
+
+      indent_width
+    end
+
+    def parse_linefeed(linefeed)
+      case linefeed.to_sym
+      when :lf
+        "\n"
+      when :lfcr
+        "\n\r"
+      when :cr
+        "\r"
+      when :crlf
+        "\r\n"
+      else
+        raise ArgumentError, 'linefeed must be one of :lf, :lfcr, :cr, :crlf'
+      end
     end
 
     def next_id
@@ -131,7 +250,7 @@ module Sass
                      out_file:,
                      functions:,
                      importer:)
-        raise ArgumentError, 'Either :data or :file must be set.' if file.nil? && data.nil?
+        raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
 
         @data = data
         @file = file
@@ -253,7 +372,7 @@ module Sass
       def url
         return if @file.nil?
 
-        Util.file_uri(@file)
+        Util.file_uri @file
       end
 
       def string
@@ -271,7 +390,7 @@ module Sass
       end
 
       def style
-        case @output_style.to_sym
+        case @output_style&.to_sym
         when :expanded
           EmbeddedProtocol::OutputStyle::EXPANDED
         when :compressed

data/lib/sass/transport.rb

@@ -25,7 +25,7 @@ module Sass
       receive
     end
 
-    def send(req, res_id)
+    def send(req, id)
       mutex = Mutex.new
       resource = ConditionVariable.new
 
@@ -37,7 +37,7 @@ module Sass
       res = nil
 
       @observerable_semaphore.synchronize do
-        MessageObserver.new self, res_id do |e, r|
+        MessageObserver.new self, id do |e, r|
           mutex.synchronize do
             error = e
             res = r

data/lib/sass/util.rb

@@ -5,16 +5,34 @@ module Sass
   module Util
     module_function
 
+    FILE_PROTOCOL = 'file://'
+
     def file_uri(path)
       absolute_path = File.absolute_path(path)
 
-      unless absolute_path.start_with?('/')
+      unless absolute_path.start_with? File::SEPARATOR
+        components = absolute_path.split File::SEPARATOR
+        components[0] = components[0][0].downcase
+        absolute_path = components.join File::SEPARATOR
+      end
+
+      "#{FILE_PROTOCOL}#{absolute_path}"
+    end
+
+    def path(file_uri)
+      absolute_path = file_uri[FILE_PROTOCOL.length..]
+
+      unless absolute_path.start_with? File::SEPARATOR
         components = absolute_path.split File::SEPARATOR
-        components[0] = components[0].split(':').first.downcase
+        components[0] = "#{components[0].upcase}:"
         absolute_path = components.join File::SEPARATOR
       end
 
-      "file://#{absolute_path}"
+      absolute_path
+    end
+
+    def relative(from, to)
+      Pathname.new(File.absolute_path(to)).relative_path_from(Pathname.new(File.absolute_path(from))).to_s
     end
 
     def now

data/lib/sass/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sass
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/test/concurrency_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class ConcurrencyTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def render(data)
+      @embedded.render(data: data)[:css]
+    end
+
+    def test_concurrency
+      10.times do
+        threads = []
+        10.times do |i|
+          threads << Thread.new(i) do |id|
+            output = @embedded.render(data: "div { width: #{id} }")[:css]
+            assert_match(/#{id}/, output)
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+  end
+end

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

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/{error_test.rb → render_error_test.rb}

@@ -3,7 +3,9 @@
 require_relative 'test_helper'
 
 module Sass
-  class ErrorTest < MiniTest::Test
+  class RenderErrorTest < MiniTest::Test
+    include TempFileTest
+
     def setup
       @embedded = Embedded.new
     end
@@ -12,7 +14,7 @@ module Sass
       @embedded.close
     end
 
-    def test_first_backtrace_is_sass
+    def test_first_backtrace_is_stdin
       template = <<~SCSS
         .foo {
           baz: bang;
@@ -25,5 +27,18 @@ module Sass
       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

data/test/{sass_test.rb → render_test.rb}

@@ -3,8 +3,8 @@
 require_relative 'test_helper'
 
 module Sass
-  class SassTest < MiniTest::Test
-    def test_sass_works
+  class RenderTest < MiniTest::Test
+    def test_sass_render
       assert_equal '', ::Sass.render(data: '')[:css]
 
       css = <<~CSS.chomp
@@ -12,6 +12,7 @@ module Sass
           font-size: 2rem;
         }
       CSS
+
       assert_equal css, ::Sass.render(data: 'h1 { font-size: 2rem; }')[:css]
     end
   end

data/test/source_maps_test.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class SourceMapsTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @embedded = Embedded.new
+    end
+
+    def teardown
+      @embedded.close
+    end
+
+    def test_no_source_map
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss')
+      assert_equal css, result[:css]
+      assert_nil result[:map]
+    end
+
+    def test_source_map_file_as_string
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+        /*# sourceMappingURL=out.map */
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: 'out.map')
+      assert_equal css, result[:css]
+      JSON.parse(result[:map])
+    end
+
+    def test_source_map_true_without_out_file_has_no_effect
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: true)
+      assert_equal css, result[:css]
+      assert_nil result[:map]
+    end
+
+    def test_source_map_true_with_out_file
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+        /*# sourceMappingURL=out.css.map */
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: true,
+                                out_file: 'out.css')
+      assert_equal css, result[:css]
+      JSON.parse(result[:map])
+    end
+
+    def test_omit_source_map_url
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: 'out.map',
+                                omit_source_map_url: true)
+      assert_equal css, result[:css]
+      JSON.parse(result[:map])
+    end
+
+    def test_source_map_embedded
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+        /*# sourceMappingURL=data:application/json;base64,
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: 'out.map',
+                                source_map_embed: true)
+      assert result[:css].start_with? css
+      JSON.parse(result[:map])
+    end
+
+    def test_source_map_root
+      scss = <<~SCSS
+        $size: 40px;
+        h1 {
+          font-size: $size;
+        }
+      SCSS
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 40px;
+        }
+        /*# sourceMappingURL=out.map */
+      CSS
+
+      temp_file('style.scss', scss)
+
+      result = @embedded.render(file: 'style.scss',
+                                source_map: 'out.map',
+                                source_map_root: 'assets')
+      assert_equal css, result[:css]
+      assert_equal 'assets', JSON.parse(result[:map])['sourceRoot']
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'fileutils'
 require 'minitest/autorun'
 require 'minitest/pride'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - なつき
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-26 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -162,12 +162,16 @@ files:
 - lib/sass/util.rb
 - lib/sass/version.rb
 - sass-embedded.gemspec
-- test/compiler_test.rb
-- test/custom_importer_test.rb
-- test/error_test.rb
+- test/concurrency_test.rb
 - test/functions_test.rb
-- test/output_style_test.rb
-- test/sass_test.rb
+- test/importer_test.rb
+- test/include_paths_test.rb
+- test/indented_syntax_test.rb
+- test/input_test.rb
+- test/output_test.rb
+- test/render_error_test.rb
+- test/render_test.rb
+- test/source_maps_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ntkme/embedded-host-ruby
 licenses:
@@ -193,10 +197,14 @@ signing_key:
 specification_version: 4
 summary: Use dart-sass with Ruby!
 test_files:
-- test/compiler_test.rb
-- test/custom_importer_test.rb
-- test/error_test.rb
+- test/concurrency_test.rb
 - test/functions_test.rb
-- test/output_style_test.rb
-- test/sass_test.rb
+- test/importer_test.rb
+- test/include_paths_test.rb
+- test/indented_syntax_test.rb
+- test/input_test.rb
+- test/output_test.rb
+- test/render_error_test.rb
+- test/render_test.rb
+- test/source_maps_test.rb
 - test/test_helper.rb

data/test/compiler_test.rb

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-module Sass
-  class EmbeddedTest < MiniTest::Test
-    include TempFileTest
-
-    def setup
-      @embedded = Embedded.new
-    end
-
-    def teardown
-      @embedded.close
-    end
-
-    def render(data)
-      @embedded.render(data: data)[:css]
-    end
-
-    def test_line_comments
-      skip 'not supported'
-
-      template = <<~SCSS
-        .foo {
-          baz: bang; }
-      SCSS
-      expected_output = <<~CSS
-        /* line 1, stdin */
-        .foo {
-          baz: bang;
-        }
-      CSS
-      output = @embedded.render(data: template,
-                                source_comments: true)
-      assert_equal expected_output, output[:css]
-    end
-
-    def test_one_line_comments
-      assert_equal <<~CSS.chomp, render(<<~SCSS)
-        .foo {
-          baz: bang;
-        }
-      CSS
-        .foo {// bar: baz;}
-          baz: bang; //}
-        }
-      SCSS
-      assert_equal <<~CSS.chomp, render(<<~SCSS)
-        .foo bar[val="//"] {
-          baz: bang;
-        }
-      CSS
-        .foo bar[val="//"] {
-          baz: bang; //}
-        }
-      SCSS
-    end
-
-    def test_variables
-      assert_equal <<~CSS.chomp, render(<<~SCSS)
-        blat {
-          a: foo;
-        }
-      CSS
-                $var: foo;
-        #{'        '}
-                blat {a: $var}
-      SCSS
-
-      assert_equal <<~CSS.chomp, render(<<~SCSS)
-        foo {
-          a: 2;
-          b: 6;
-        }
-      CSS
-        foo {
-          $var: 2;
-          $another-var: 4;
-          a: $var;
-          b: $var + $another-var;}
-      SCSS
-    end
-
-    def test_precision
-      skip 'not supported'
-
-      template = <<~SCSS
-        $var: 1;
-        .foo {
-          baz: $var / 3; }
-      SCSS
-      expected_output = <<~CSS.chomp
-        .foo {
-          baz: 0.33333333;
-        }
-      CSS
-      output = @embedded.render(data: template,
-                                precision: 8)
-      assert_equal expected_output, output
-    end
-
-    def test_precision_not_specified
-      template = <<~SCSS
-        $var: 1;
-        .foo {
-          baz: $var / 3; }
-      SCSS
-      expected_output = <<~CSS.chomp
-        .foo {
-          baz: 0.3333333333;
-        }
-      CSS
-      output = render(template)
-      assert_equal expected_output, output
-    end
-
-    def test_source_map
-      temp_dir('admin')
-
-      temp_file('admin/text-color.scss', <<~SCSS)
-        p {
-          color: red;
-        }
-      SCSS
-      temp_file('style.scss', <<~SCSS)
-                @use 'admin/text-color';
-        #{'        '}
-                p {
-                  padding: 20px;
-                }
-      SCSS
-      output = @embedded.render(data: File.read('style.scss'),
-                                source_map: 'style.scss.map')
-
-      assert output[:map].start_with? '{"version":3,'
-    end
-
-    def test_no_source_map
-      output = @embedded.render(data: '$size: 30px;')
-      assert_equal '', output[:map]
-    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; }")
-
-      assert_equal ".hi {\n  width: 30px;\n}", @embedded.render(data: File.read('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'
-
-      assert_equal ".hi {\n  width: 30px;\n}", render(File.read('styles.scss'))
-    end
-
-    def test_env_include_paths
-      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
-        render(File.read('styles.scss'))
-      end
-    end
-
-    def test_sass_variation
-      sass = <<~SASS
-        $size: 30px
-        .foo
-          width: $size
-      SASS
-
-      css = <<~CSS.chomp
-        .foo {
-          width: 30px;
-        }
-      CSS
-
-      assert_equal css, @embedded.render(data: sass, indented_syntax: true)[:css]
-      assert_raises(RenderError) do
-        @embedded.render(data: sass, indented_syntax: false)
-      end
-    end
-
-    def test_inline_source_maps
-      skip 'not supported'
-
-      template = <<~SCSS
-        .foo {
-          baz: bang; }
-      SCSS
-
-      output = @embedded.render(data: template,
-                                source_map: '.',
-                                source_map_embed: true,
-                                source_map_contents: true)[:css]
-
-      assert_match(/sourceMappingURL/, output)
-      assert_match(/.foo/, output)
-    end
-
-    def test_empty_template
-      output = render('')
-      assert_equal '', output
-    end
-
-    def test_import_plain_css
-      temp_file('test.css', '.something{color: red}')
-      expected_output = <<~CSS.chomp
-        .something {
-          color: red;
-        }
-      CSS
-
-      output = render("@use 'test';")
-      assert_equal expected_output, output
-    end
-
-    def test_concurrency
-      10.times do
-        threads = []
-        10.times do |i|
-          threads << Thread.new(i) do |id|
-            output = @embedded.render(data: "div { width: #{id} }")[:css]
-            assert_match(/#{id}/, output)
-          end
-        end
-        threads.each(&:join)
-      end
-    end
-  end
-end

data/test/output_style_test.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-module Sass
-  class OutputStyleTest < MiniTest::Test
-    def setup
-      @embedded = Embedded.new
-    end
-
-    def teardown
-      @embedded.close
-    end
-
-    def input_scss
-      <<~CSS
-        $color: #fff;
-
-        #main {
-          color: $color;
-          background-color: #000;
-          p {
-            width: 10em;
-          }
-        }
-
-        .huge {
-          font-size: 10em;
-          font-weight: bold;
-          text-decoration: underline;
-        }
-      CSS
-    end
-
-    def expected_expanded_output
-      <<~CSS.chomp
-        #main {
-          color: #fff;
-          background-color: #000;
-        }
-        #main p {
-          width: 10em;
-        }
-
-        .huge {
-          font-size: 10em;
-          font-weight: bold;
-          text-decoration: underline;
-        }
-      CSS
-    end
-
-    def test_expanded_output_is_default
-      output = @embedded.render(data: input_scss)[:css]
-      assert_equal expected_expanded_output, output
-    end
-
-    def test_output_style_accepts_strings
-      output = @embedded.render(data: input_scss, output_style: :expanded)[:css]
-      assert_equal expected_expanded_output, output
-    end
-
-    def test_invalid_output_style
-      assert_raises(ArgumentError) do
-        @embedded.render(data: input_scss, output_style: :totally_wrong)[:css]
-      end
-    end
-
-    def test_unsupported_output_style
-      assert_raises(ArgumentError) do
-        @embedded.render(data: input_scss, output_style: :nested)[:css]
-      end
-
-      assert_raises(ArgumentError) do
-        @embedded.render(data: input_scss, output_style: :compact)[:css]
-      end
-    end
-
-    def test_compressed_output
-      output = @embedded.render(data: input_scss, output_style: :compressed)[:css]
-      assert_equal <<~CSS.chomp, output
-        #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
-      CSS
-    end
-
-    def test_string_output_style_names
-      output = @embedded.render(data: input_scss, output_style: 'compressed')[:css]
-      assert_equal <<~CSS.chomp, output
-        #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
-      CSS
-    end
-  end
-end