sassc4 2.4.0

data/test/css_color_level4_test.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class CSSColorLevel4Test < MiniTest::Test
+    include FixtureHelper
+
+    def test_rgb_with_space_separated_values_and_alpha_slash
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(100% 0% 0% / 50%); }
+      SCSS
+        div { color: rgba(255, 0, 0, 0.5); }
+      CSS
+    end
+
+    def test_rgb_with_space_separated_values_without_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(100% 0% 0%); }
+      SCSS
+        div { color: red; }
+      CSS
+    end
+
+    def test_rgb_with_numeric_values_and_alpha_slash
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(255 0 0 / 0.5); }
+      SCSS
+        div { color: rgba(255, 0, 0, 0.5); }
+      CSS
+    end
+
+    def test_rgb_with_numeric_values_and_percent_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(255 0 0 / 100%); }
+      SCSS
+        div { color: red; }
+      CSS
+    end
+
+    def test_rgba_with_space_separated_values_and_alpha_slash
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgba(50% 100% 0% / 75%); }
+      SCSS
+        div { color: rgba(128, 255, 0, 0.75); }
+      CSS
+    end
+
+    def test_hsl_with_space_separated_values_and_alpha_slash
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(120deg 100% 50% / 50%); }
+      SCSS
+        div { color: rgba(0, 255, 0, 0.5); }
+      CSS
+    end
+
+    def test_hsl_with_space_separated_values_without_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(240deg 100% 50%); }
+      SCSS
+        div { color: blue; }
+      CSS
+    end
+
+    def test_hsl_without_deg_unit
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(180 50% 50% / 0.8); }
+      SCSS
+        div { color: rgba(64, 191, 191, 0.8); }
+      CSS
+    end
+
+    def test_hsla_with_space_separated_values_and_alpha_slash
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsla(0deg 100% 50% / 25%); }
+      SCSS
+        div { color: red; }
+      CSS
+    end
+
+    def test_mixed_color_syntax_in_same_file
+      assert_sass <<-SCSS, <<-CSS
+        .old-rgb { color: rgb(255, 0, 0); }
+        .new-rgb { color: rgb(255 0 0 / 0.5); }
+        .old-hsl { color: hsl(120, 100%, 50%); }
+        .new-hsl { color: hsl(120deg 100% 50% / 0.5); }
+      SCSS
+        .old-rgb { color: red; }
+        .new-rgb { color: rgba(255, 0, 0, 0.5); }
+        .old-hsl { color: lime; }
+        .new-hsl { color: rgba(0, 255, 0, 0.5); }
+      CSS
+    end
+
+    def test_rgb_with_zero_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(255 128 64 / 0%); }
+      SCSS
+        div { color: rgba(255, 128, 64, 0); }
+      CSS
+    end
+
+    def test_hsl_with_full_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(60deg 100% 50% / 100%); }
+      SCSS
+        div { color: yellow; }
+      CSS
+    end
+
+    def test_rgb_with_decimal_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(200 100 50 / 0.333); }
+      SCSS
+        div { color: rgba(200, 100, 50, 0.333); }
+      CSS
+    end
+
+    def test_hsl_with_decimal_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(90 80% 60% / 0.666); }
+      SCSS
+        div { color: rgba(153, 235, 71, 0.666); }
+      CSS
+    end
+
+    def test_rgb_percent_mixed_with_alpha
+      assert_sass <<-SCSS, <<-CSS
+        div { color: rgb(50% 25% 75% / 0.5); }
+      SCSS
+        div { color: rgba(128, 64, 191, 0.5); }
+      CSS
+    end
+
+    def test_hsl_with_turn_unit
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(0.5turn 50% 50% / 50%); }
+      SCSS
+        div { color: rgba(191, 65, 64, 0.5); }
+      CSS
+    end
+
+    def test_hsl_with_rad_unit
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(3.14159rad 100% 50% / 80%); }
+      SCSS
+        div { color: rgba(255, 13, 0, 0.8); }
+      CSS
+    end
+
+    def test_hsl_with_grad_unit
+      assert_sass <<-SCSS, <<-CSS
+        div { color: hsl(200grad 50% 50% / 60%); }
+      SCSS
+        div { color: rgba(64, 149, 191, 0.6); }
+      CSS
+    end
+
+    private
+
+    def assert_sass(sass, expected_css)
+      engine = Engine.new(sass)
+      assert_equal expected_css.strip.gsub(/\s+/, " "), # poor man's String#squish
+                   engine.render.strip.gsub(/\s+/, " ")
+    end
+  end
+end
+

data/test/custom_importer_test.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class CustomImporterTest < MiniTest::Test
+    include TempFileTest
+
+    class CustomImporter < Importer
+      def imports(path, parent_path)
+        if path =~ /styles/
+          [
+            Import.new("#{path}1.scss", source: "$var1: #000;"),
+            Import.new("#{path}2.scss")
+          ]
+        else
+          Import.new(path)
+        end
+      end
+    end
+
+    class NoFilesImporter < Importer
+      def imports(path, parent_path)
+        []
+      end
+    end
+
+    class OptionsImporter < Importer
+      def imports(path, parent_path)
+        Import.new("name.scss", source: options[:custom_option_source])
+      end
+    end
+
+    class ParentImporter < Importer
+      def imports(path, parent_path)
+        Import.new("name.scss", source: ".#{parent_path} { color: red; }")
+      end
+    end
+
+    def test_custom_importer_works
+      temp_file("styles2.scss", ".hi { color: $var1; }")
+      temp_file("fonts.scss", ".font { color: $var1; }")
+
+      data = <<SCSS
+@import "styles";
+@import "fonts";
+SCSS
+
+      engine = Engine.new(data, {
+        importer: CustomImporter
+      })
+
+      assert_equal <<CSS, engine.render
+.hi {
+  color: #000; }
+
+.font {
+  color: #000; }
+CSS
+    end
+
+    def test_dependency_list
+      base = temp_dir("").to_s
+
+      temp_dir("fonts")
+      temp_dir("fonts/sub")
+      temp_file("fonts/sub/sub_fonts.scss", "$font: arial;")
+      temp_file("styles2.scss", ".hi { color: $var1; }")
+      temp_file "fonts/fonts.scss", <<SCSS
+@import "sub/sub_fonts";
+.font { font-familiy: $font; color: $var1; }
+SCSS
+
+      data = <<SCSS
+@import "styles";
+@import "fonts";
+SCSS
+
+      engine = Engine.new(data, {
+        importer: CustomImporter,
+        load_paths: ["fonts"]
+      })
+      engine.render
+
+      dependencies = engine.dependencies.map(&:filename).map { |f| f.gsub(base, "") }
+
+      assert_equal [
+        "/fonts/sub/sub_fonts.scss",
+        "/styles2.scss",
+        "fonts/fonts.scss",
+        "styles1.scss"
+      ], dependencies
+    end
+
+    def test_custom_importer_works_with_no_files
+      engine = Engine.new("@import 'fake.scss';", {
+        importer: NoFilesImporter
+      })
+
+      assert_equal "", engine.render
+    end
+
+    def test_custom_importer_can_access_sassc_options
+      engine = Engine.new("@import 'fake.scss';", {
+        importer: OptionsImporter,
+        custom_option_source: ".test { width: 30px; }"
+      })
+
+      assert_equal <<CSS, engine.render
+.test {
+  width: 30px; }
+CSS
+    end
+
+    def test_parent_path_is_accessible
+      engine = Engine.new("@import 'parent.scss';", {
+        importer: ParentImporter,
+        filename: "import-parent-filename.scss"
+      })
+
+      assert_equal <<CSS, engine.render
+.import-parent-filename.scss {
+  color: red; }
+CSS
+    end
+  end
+end

data/test/engine_test.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class EngineTest < MiniTest::Test
+    include TempFileTest
+
+    def render(data)
+      Engine.new(data).render
+    end
+
+    def test_line_comments
+      template = <<-SCSS
+.foo {
+  baz: bang; }
+      SCSS
+      expected_output = <<-CSS
+/* line 1, stdin */
+.foo {
+  baz: bang; }
+      CSS
+      output = Engine.new(template, line_comments: true).render
+      assert_equal expected_output, output
+    end
+
+    def test_one_line_comments
+      assert_equal <<CSS, render(<<SCSS)
+.foo {
+  baz: bang; }
+CSS
+.foo {// bar: baz;}
+  baz: bang; //}
+}
+SCSS
+      assert_equal <<CSS, render(<<SCSS)
+.foo bar[val="//"] {
+  baz: bang; }
+CSS
+.foo bar[val="//"] {
+  baz: bang; //}
+}
+SCSS
+  end
+
+    def test_variables
+      assert_equal <<CSS, render(<<SCSS)
+blat {
+  a: foo; }
+CSS
+$var: foo;
+
+blat {a: $var}
+SCSS
+
+      assert_equal <<CSS, 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
+      template = <<-SCSS
+$var: 1;
+.foo {
+  baz: $var / 3; }
+SCSS
+      expected_output = <<-CSS
+.foo {
+  baz: 0.33333333; }
+CSS
+      output = Engine.new(template, precision: 8).render
+      assert_equal expected_output, output
+    end
+
+    def test_precision_not_specified
+      template = <<-SCSS
+$var: 1;
+.foo {
+  baz: $var / 3; }
+SCSS
+      expected_output = <<-CSS
+.foo {
+  baz: 0.3333333333; }
+CSS
+      output = Engine.new(template).render
+      assert_equal expected_output, output
+    end
+
+    def test_dependency_filenames_are_reported
+      base = temp_dir("").to_s
+
+      temp_file("not_included.scss", "$size: 30px;")
+      temp_file("import_parent.scss", "$size: 30px;")
+      temp_file("import.scss", "@import 'import_parent'; $size: 30px;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+
+      engine = Engine.new(File.read("styles.scss"))
+      engine.render
+      deps = engine.dependencies
+
+      expected = ["/import.scss", "/import_parent.scss"]
+      assert_equal expected, deps.map { |dep| dep.options[:filename].gsub(base, "") }.sort
+      assert_equal expected, deps.map { |dep| dep.filename.gsub(base, "") }.sort
+    end
+
+    def test_no_dependencies
+      engine = Engine.new("$size: 30px;")
+      engine.render
+      deps = engine.dependencies
+      assert_equal [], deps
+    end
+
+    def test_not_rendered_error
+      engine = Engine.new("$size: 30px;")
+      assert_raises(NotRenderedError) { engine.dependencies }
+    end
+
+    def test_source_map
+      temp_dir('admin')
+
+      temp_file('admin/text-color.scss', <<SCSS)
+p {
+  color: red;
+}
+SCSS
+      temp_file('style.scss', <<SCSS)
+@import 'admin/text-color';
+
+p {
+  padding: 20px;
+}
+SCSS
+      engine = Engine.new(File.read('style.scss'), {
+        source_map_file: "style.scss.map",
+        source_map_contents: true
+      })
+      engine.render
+
+      assert_equal <<MAP.strip, engine.source_map
+{
+\t"version": 3,
+\t"file": "stdin.css",
+\t"sources": [
+\t\t"stdin",
+\t\t"admin/text-color.scss"
+\t],
+\t"sourcesContent": [
+\t\t"@import 'admin/text-color';\\n\\np {\\n  padding: 20px;\\n}\\n",
+\t\t"p {\\n  color: red;\\n}\\n"
+\t],
+\t"names": [],
+\t"mappings": "ACAA,AAAA,CAAC,CAAC;EACA,KAAK,EAAE,GAAG,GACX;;ADAD,AAAA,CAAC,CAAC;EACA,OAAO,EAAE,IAAI,GACd"
+}
+MAP
+    end
+
+    def test_no_source_map
+      engine = Engine.new("$size: 30px;")
+      engine.render
+      assert_raises(NotRenderedError) { engine.source_map }
+    end
+
+    def test_omit_source_map_url
+      temp_file('style.scss', <<SCSS)
+p {
+  padding: 20px;
+}
+SCSS
+      engine = Engine.new(File.read('style.scss'), {
+        source_map_file: "style.scss.map",
+        source_map_contents: true,
+        omit_source_map_url: true
+      })
+      output = engine.render
+
+      refute_match /sourceMappingURL/, output
+    end
+
+    def test_load_paths
+      temp_dir("included_1")
+      temp_dir("included_2")
+
+      temp_file("included_1/import_parent.scss", "$s: 30px;")
+      temp_file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+
+      assert_equal ".hi {\n  width: 30px; }\n", Engine.new(
+        File.read("styles.scss"),
+        load_paths: [ "included_1", "included_2" ]
+      ).render
+    end
+
+    def test_global_load_paths
+      temp_dir("included_1")
+      temp_dir("included_2")
+
+      temp_file("included_1/import_parent.scss", "$s: 30px;")
+      temp_file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+
+      ::SassC.load_paths << "included_1"
+      ::SassC.load_paths << "included_2"
+
+      assert_equal ".hi {\n  width: 30px; }\n", Engine.new(
+        File.read("styles.scss"),
+      ).render
+      ::SassC.load_paths.clear
+    end
+
+    def test_env_load_paths
+      expected_load_paths = [ "included_1", "included_2" ]
+      ::SassC.instance_eval { @load_paths = nil }
+      ENV['SASS_PATH'] = expected_load_paths.join(File::PATH_SEPARATOR)
+      assert_equal expected_load_paths, ::SassC.load_paths
+      ::SassC.load_paths.clear
+    end
+
+    def test_load_paths_not_configured
+      temp_file("included_1/import_parent.scss", "$s: 30px;")
+      temp_file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+
+      assert_raises(SyntaxError) do
+        Engine.new(File.read("styles.scss")).render
+      end
+    end
+
+    def test_sass_variation
+      sass = <<SASS
+$size: 30px
+.foo
+  width: $size
+SASS
+
+    css = <<CSS
+.foo {
+  width: 30px; }
+CSS
+
+      assert_equal css, Engine.new(sass, syntax: :sass).render
+      assert_equal css, Engine.new(sass, syntax: "sass").render
+      assert_raises(SyntaxError) { Engine.new(sass).render }
+    end
+
+    def test_encoding_matches_input
+      input = String.new("$size: 30px;")
+      input.force_encoding("UTF-8")
+      output = Engine.new(input).render
+      assert_equal input.encoding, output.encoding
+    end
+
+    def test_inline_source_maps
+      template = <<-SCSS
+.foo {
+  baz: bang; }
+      SCSS
+      expected_output = <<-CSS
+/* line 1, stdin */
+.foo {
+  baz: bang; }
+      CSS
+
+      output = Engine.new(template, {
+        source_map_file: ".",
+        source_map_embed: true,
+        source_map_contents: true
+      }).render
+
+      assert_match /sourceMappingURL/, output
+      assert_match /.foo/, output
+    end
+
+    def test_empty_template
+      output = Engine.new('').render
+      assert_equal '', output
+    end
+
+    def test_empty_template_returns_a_new_object
+      input = String.new
+      output = Engine.new(input).render
+      assert !input.equal?(output), 'empty template must return a new object'
+    end
+
+    def test_empty_template_encoding_matches_input
+      input = String.new.force_encoding("ISO-8859-1")
+      output = Engine.new(input).render
+      assert_equal input.encoding, output.encoding
+    end
+
+    def test_handling_of_frozen_strings
+      output = Engine.new("body { background-color: red; }".freeze).render
+      assert_equal output, "body {\n  background-color: red; }\n"
+    end
+
+    def test_import_plain_css
+      temp_file("test.css", ".something{color: red}")
+      expected_output = <<-CSS
+.something {
+  color: red; }
+      CSS
+
+      output = Engine.new("@import 'test'").render
+      assert_equal expected_output, output
+    end
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class ErrorTest < MiniTest::Test
+    def render(data, opts={})
+      Engine.new(data, opts).render
+    end
+
+    def test_first_backtrace_is_sass
+      filename = "app/assets/stylesheets/application.scss"
+
+      begin
+        template = <<-SCSS
+.foo {
+  baz: bang;
+  padding top: 10px;
+}
+      SCSS
+
+        render(template, filename: filename)
+      rescue SassC::SyntaxError => err
+        expected = "#{filename}:3"
+        assert_equal expected, err.backtrace.first
+      end
+    end
+  end
+end

data/test/fixtures/paths.scss

@@ -0,0 +1,10 @@
+div {
+   url: url(asset-path("foo.svg"));
+   url: url(image-path("foo.png"));
+   url: url(video-path("foo.mov"));
+   url: url(audio-path("foo.mp3"));
+   url: url(font-path("foo.woff"));
+   url: url(javascript-path('foo.js'));
+   url: url(javascript-path("foo.js"));
+   url: url(stylesheet-path("foo.css"));
+}