sass-embedded 0.1.0

data/test/custom_importer_test.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module Sass
+  class CustomImporterTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @compiler = Embedded::Compiler.new
+    end
+
+    def teardown
+    end
+
+    def render(data, importer)
+      @compiler.render({ data: data, importer: importer })[:css]
+    end
+
+    def test_custom_importer_works
+      temp_file("fonts.scss", ".font { color: $var1; }")
+
+      data = <<SCSS
+@import "styles";
+@import "fonts";
+SCSS
+
+      output = render(data, [
+        lambda { |url, prev|
+          if url =~ /styles/
+            { contents: "$var1: #000; .hi { color: $var1; }" }
+          end
+        }
+      ])
+
+      assert_equal <<CSS.chomp, output
+.hi {
+  color: #000;
+}
+
+.font {
+  color: #000;
+}
+CSS
+    end
+
+    def test_custom_importer_works_with_empty_contents
+      output = render("@import 'fake.scss';", [
+        lambda { |url, prev|
+          { contents: "" }
+        }
+      ])
+
+      assert_equal "", output
+    end
+
+    def test_custom_importer_works_with_file
+      temp_file("test.scss", ".test { color: #000; }")
+
+      output = render("@import 'fake.scss';", [
+        lambda { |url, prev|
+          { file: File.absolute_path("test.scss") }
+        }
+      ])
+
+      assert_equal <<CSS.chomp, output
+.test {
+  color: #000;
+}
+CSS
+    end
+
+    def test_custom_importer_comes_after_local_file
+      temp_file("test.scss", ".test { color: #000; }")
+
+      output = render("@import 'test.scss';", [
+        lambda { |url, prev|
+          return { contents: '.h1 { color: #fff; }' }
+        }
+      ])
+
+      assert_equal <<CSS.chomp, output
+.test {
+  color: #000;
+}
+CSS
+    end
+
+    def test_custom_importer_that_does_not_resolve
+      assert_raises(CompilationError) do
+        output = render("@import 'test.scss';", [
+          lambda { |url, prev|
+            return nil
+          }
+        ])
+      end
+    end
+
+    def test_custom_importer_that_returns_error
+      assert_raises(CompilationError) do
+        output = render("@import 'test.scss';", [
+          lambda { |url, prev|
+            IOError.new "test error"
+          }
+        ])
+      end
+    end
+
+    def test_custom_importer_that_raises_error
+      assert_raises(CompilationError) do
+        output = render("@import 'test.scss';", [
+          lambda { |url, prev|
+            raise IOError.new "test error"
+          }
+        ])
+      end
+    end
+
+    def test_parent_path_is_accessible
+      output = @compiler.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 {
+  color: red;
+}
+CSS
+    end
+
+    def test_call_compiler_importer
+      output = @compiler.render({
+        data: "@import 'parent.scss';",
+        importer: [
+          lambda { |url, prev|
+            {
+              contents: @compiler.render({
+                data: "@import 'parent-parent.scss'",
+                importer: [
+                  lambda { |url, prev|
+                    { contents: 'h1 { color: black; }' }
+                  }
+                ]})[:css]
+            }
+          }
+        ]})[:css]
+
+      assert_equal <<CSS.chomp, output
+h1 {
+  color: black;
+}
+CSS
+    end
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module Sass
+  class ErrorTest < MiniTest::Test
+
+    def setup
+      @compiler = Embedded::Compiler.new
+    end
+
+    def teardown
+    end
+
+    def test_first_backtrace_is_sass
+      begin
+        template = <<-SCSS
+.foo {
+  baz: bang;
+  padding top: 10px;
+}
+      SCSS
+
+        @compiler.render({
+          data: template,
+        })
+      rescue Sass::CompilationError => err
+        expected = "stdin:3:20"
+        assert_equal expected, err.backtrace.first
+      end
+    end
+  end
+end

data/test/functions_test.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "stringio"
+
+module Sass
+  class FunctionsTest < MiniTest::Test
+    def setup
+      @compiler = Embedded::Compiler.new
+    end
+
+    def teardown
+    end
+
+    def render(sass)
+      @compiler.render({
+        data: sass,
+        functions: {
+          'javascript_path($path)': lambda { |path|
+            path.string.text = "/js/#{path.string.text}"
+            path
+          },
+          'stylesheet_path($path)': lambda { |path|
+            path.string.text = "/css/#{path.string.text}"
+            path
+          },
+          'sass_return_path($path)': lambda { |path|
+            path
+          },
+          'no_return_path($path)': lambda { |path|
+            Sass::EmbeddedProtocol::Value.new(
+              :singleton => Sass::EmbeddedProtocol::SingletonValue::NULL
+            )
+          },
+          'optional_arguments($path, $optional: null)': lambda { |path, optional|
+            Sass::EmbeddedProtocol::Value.new(
+              :string => Sass::EmbeddedProtocol::Value::String.new(
+                :text => "#{path.string.text}/#{optional.singleton == :NULL ? "bar" : optional.string.text}",
+                :quoted => true
+              )
+            )
+          },
+          'function_that_raises_errors()': lambda {
+            raise StandardError, "Intentional wrong thing happened somewhere inside the custom function"
+          },
+          'nice_color_argument($color)': lambda { |color|
+            color
+          },
+          'returns_a_color()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :rgb_color => Sass::EmbeddedProtocol::Value::RgbColor.new(
+                :red   => 0,
+                :green => 0,
+                :blue  => 0,
+                :alpha => 1
+              )
+            )
+          },
+          'returns_a_number()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :number => Sass::EmbeddedProtocol::Value::Number.new(
+                :value => -312,
+                :numerators => ['rem']
+              )
+            )
+          },
+          'returns_a_bool()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :singleton => Sass::EmbeddedProtocol::SingletonValue::TRUE
+            )
+          },
+          'inspect_bool($argument)': lambda { |argument|
+            raise StandardError.new "passed value is not a Sass::EmbeddedProtocol::SingletonValue::TRUE or Sass::EmbeddedProtocol::SingletonValue::FALSE" unless argument&.singleton == :TRUE || argument.singleton == :FALSE
+            argument
+          },
+          'inspect_number($argument)': lambda { |argument|
+            raise StandardError.new "passed value is not a Sass::EmbeddedProtocol::Value::Number" unless argument&.number&.is_a? Sass::EmbeddedProtocol::Value::Number
+            argument
+          },
+          'inspect_map($argument)': lambda { |argument|
+            raise StandardError.new "passed value is not a Sass::EmbeddedProtocol::Value::Map" unless argument&.map&.is_a? Sass::EmbeddedProtocol::Value::Map
+            argument
+          },
+          'inspect_list($argument)': lambda { |argument|
+            raise StandardError.new "passed value is not a Sass::EmbeddedProtocol::Value::List" unless argument&.list&.is_a? Sass::EmbeddedProtocol::Value::List
+            argument
+          },
+          'returns_sass_value()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :rgb_color => Sass::EmbeddedProtocol::Value::RgbColor.new(
+                :red   => 0,
+                :green => 0,
+                :blue  => 0,
+                :alpha => 1
+              )
+            )
+          },
+          'returns_sass_map()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :map => Sass::EmbeddedProtocol::Value::Map.new(
+                :entries => [
+                  Sass::EmbeddedProtocol::Value::Map::Entry.new(
+                    :key => Sass::EmbeddedProtocol::Value.new(
+                      :string => Sass::EmbeddedProtocol::Value::String.new(
+                        :text => "color",
+                        :quoted => true
+                      )
+                    ),
+                    :value => Sass::EmbeddedProtocol::Value.new(
+                      :rgb_color => Sass::EmbeddedProtocol::Value::RgbColor.new(
+                        :red   => 0,
+                        :green => 0,
+                        :blue  => 0,
+                        :alpha => 1
+                      )
+                    )
+                  )
+                ]
+              )
+            )
+          },
+          'returns_sass_list()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :list => Sass::EmbeddedProtocol::Value::List.new(
+                :separator => Sass::EmbeddedProtocol::ListSeparator::COMMA,
+                :has_brackets => true,
+                :contents => [
+                  Sass::EmbeddedProtocol::Value.new(
+                    :number => Sass::EmbeddedProtocol::Value::Number.new(
+                      :value => 10
+                    )
+                  ),
+                  Sass::EmbeddedProtocol::Value.new(
+                    :number => Sass::EmbeddedProtocol::Value::Number.new(
+                      :value => 20
+                    )
+                  ),
+                  Sass::EmbeddedProtocol::Value.new(
+                    :number => Sass::EmbeddedProtocol::Value::Number.new(
+                      :value => 30
+                    )
+                  ),
+                ]
+              )
+            )
+          }
+        }
+      })[:css]
+    end
+
+    def test_functions_may_return_sass_string_type
+      assert_sass <<-SCSS, <<-CSS
+        div { url: url(sass_return_path("foo.svg")); }
+      SCSS
+        div { url: url("foo.svg"); }
+      CSS
+    end
+
+    def test_functions_work_with_varying_quotes_and_string_types
+      assert_sass <<-SCSS, <<-CSS
+        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"));
+        }
+      SCSS
+        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("/js/foo.js");
+          url: url("/js/foo.js");
+          url: url("/css/foo.css");
+        }
+      CSS
+    end
+
+    def test_function_with_empty_unquoted_string
+      assert_sass <<-SCSS, <<-CSS
+        div {url: url(no-return-path('foo.svg'));}
+      SCSS
+        div { url: url(); }
+      CSS
+    end
+
+    def test_function_that_returns_a_color
+      assert_sass <<-SCSS, <<-CSS
+        div { background: returns-a-color(); }
+      SCSS
+        div { background: black; }
+      CSS
+    end
+
+    def test_function_that_returns_a_number
+      assert_sass <<-SCSS, <<-CSS
+        div { width: returns-a-number(); }
+      SCSS
+        div { width: -312rem; }
+      CSS
+    end
+
+    def test_function_that_takes_a_number
+      assert_sass <<-SCSS, <<-CSS
+        div { display: inspect-number(42.1px); }
+      SCSS
+        div { display: 42.1px; }
+      CSS
+    end
+
+    def test_function_that_returns_a_bool
+      assert_sass <<-SCSS, <<-CSS
+        div { width: returns-a-bool(); }
+      SCSS
+        div { width: true; }
+      CSS
+    end
+
+    def test_function_that_takes_a_bool
+      assert_sass <<-SCSS, <<-CSS
+        div { display: inspect-bool(true)}
+      SCSS
+        div { display: true; }
+      CSS
+    end
+
+    def test_function_with_optional_arguments
+      assert_sass <<-SCSS, <<-EXPECTED_CSS
+        div {
+          url: optional_arguments('first');
+          url: optional_arguments('second', 'qux');
+        }
+      SCSS
+        div {
+          url: "first/bar";
+          url: "second/qux";
+        }
+      EXPECTED_CSS
+    end
+
+    def test_functions_may_accept_sass_color_type
+      assert_sass <<-SCSS, <<-EXPECTED_CSS
+        div { color: nice_color_argument(red); }
+      SCSS
+        div { color: red; }
+      EXPECTED_CSS
+    end
+
+    def test_function_with_error
+      exception = assert_raises(Sass::CompilationError) do
+        render("div {url: function_that_raises_errors();}")
+      end
+    end
+
+    def test_function_that_returns_a_sass_value
+      assert_sass <<-SCSS, <<-CSS
+        div { background: returns-sass-value(); }
+      SCSS
+        div { background: black; }
+      CSS
+    end
+
+    def test_function_that_returns_a_sass_map
+      assert_sass <<-SCSS, <<-CSS
+        $my-map: returns-sass-map();
+        div { background: map-get( $my-map, color ); }
+      SCSS
+        div { background: black; }
+      CSS
+    end
+
+    def test_function_that_takes_a_sass_map
+      assert_sass <<-SCSS, <<-CSS
+        div { background-color: map-get( inspect-map(( color: black, number: 1.23px, string: "abc", map: ( x: 'y' ))), color ); }
+      SCSS
+        div { background-color: black; }
+      CSS
+    end
+
+    def test_function_that_returns_a_sass_list
+      assert_sass <<-SCSS, <<-CSS
+        $my-list: returns-sass-list();
+        div { width: nth( $my-list, 2 ); }
+      SCSS
+        div { width: 20; }
+      CSS
+    end
+
+    def test_function_that_takes_a_sass_list
+      assert_sass <<-SCSS, <<-CSS
+        div { width: nth(inspect-list((10 20 30)), 2); }
+      SCSS
+        div { width: 20; }
+      CSS
+    end
+
+    def test_concurrency
+      skip 'ProtocolError: Bad state: Future already completed'
+      10.times do
+        threads = []
+        2.times do |i|
+          threads << Thread.new(i) do |id|
+            output = @compiler.render({
+              data: "div { url: test-function() }",
+              functions: {
+                'test_function()': lambda {
+                  Sass::EmbeddedProtocol::Value.new(
+                    :string => Sass::EmbeddedProtocol::Value::String.new(
+                      :text => "{test_key1: 'test_value', test_key2: #{id}}",
+                      :quoted => true
+                    )
+                  )
+                }
+              }
+            })[:css]
+            assert_match /test_key1/, output
+            assert_match /test_key2/, output
+            assert_match /test_value/, output
+            assert_match /#{id}/, output
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+
+    def test_pass_custom_functions_as_a_parameter
+      output = @compiler.render({
+        data: "div { url: test-function(); }",
+        functions: {
+          'test_function()': lambda {
+            Sass::EmbeddedProtocol::Value.new(
+              :string => Sass::EmbeddedProtocol::Value::String.new(
+                :text => "custom_function",
+                :quoted => true
+              )
+            )
+          }
+        }
+      })[:css]
+
+      assert_match /custom_function/, output
+    end
+
+    def test_pass_incompatible_type_to_custom_functions
+      assert_raises(CompilationError) do
+        output = @compiler.render({
+          data: "div { url: test-function(); }",
+          functions: {
+            'test_function()': lambda {
+              Class.new
+            }
+          }
+        })[:css]
+      end
+    end
+
+    private
+
+    def assert_sass(sass, expected_css)
+      output = render(sass)
+      assert_equal expected_css.strip.gsub!(/\s+/, " "), # poor man's String#squish
+                   output.strip.gsub!(/\s+/, " ")
+    end
+
+    def stderr_output
+      $stderr.string.gsub("\u0000\n", '').chomp
+    end
+  end
+end