sassc 2.1.0.pre1-x86-mingw32

data/test/functions_test.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "stringio"
+
+module SassC
+  class FunctionsTest < MiniTest::Test
+    include FixtureHelper
+
+    def setup
+      @real_stderr, $stderr = $stderr, StringIO.new
+    end
+
+    def teardown
+      $stderr = @real_stderr
+    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_no_return_value
+      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: rgb(255, 0, 0); }
+      EXPECTED_CSS
+    end
+
+    def test_function_with_unsupported_tag
+      skip('What are other unsupported tags?')
+      engine = Engine.new("div {url: function_with_unsupported_tag(());}")
+
+      exception = assert_raises(SassC::SyntaxError) do
+        engine.render
+      end
+
+      assert_match /Sass argument of type sass_list unsupported/, exception.message
+      assert_equal "[SassC::FunctionsHandler] Sass argument of type sass_list unsupported", stderr_output
+    end
+
+    def test_function_with_error
+      engine = Engine.new("div {url: function_that_raises_errors();}")
+
+      exception = assert_raises(SassC::SyntaxError) do
+        engine.render
+      end
+
+      assert_match /Error: error in C function function_that_raises_errors/, exception.message
+      assert_match /Intentional wrong thing happened somewhere inside the custom function/, exception.message
+      assert_equal "[SassC::FunctionsHandler] Intentional wrong thing happened somewhere inside the custom function", stderr_output
+    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
+
+    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
+
+    def stderr_output
+      $stderr.string.gsub("\u0000\n", '').chomp
+    end
+
+    module Script::Functions
+
+      def javascript_path(path)
+        SassC::Script::Value::String.new("/js/#{path.value}", :string)
+      end
+
+      def stylesheet_path(path)
+        SassC::Script::Value::String.new("/css/#{path.value}", :identifier)
+      end
+
+      def no_return_path(path)
+        nil
+      end
+
+      def sass_return_path(path)
+        SassC::Script::Value::String.new("#{path.value}", :string)
+      end
+
+      def optional_arguments(path, optional = nil)
+        optional ||= SassC::Script::Value::String.new("bar")
+        SassC::Script::Value::String.new("#{path.value}/#{optional.value}", :string)
+      end
+
+      def function_that_raises_errors
+        raise StandardError, "Intentional wrong thing happened somewhere inside the custom function"
+      end
+
+      def function_with_unsupported_tag(value)
+      end
+
+      def nice_color_argument(color)
+        return SassC::Script::Value::String.new(color.to_s, :identifier)
+      end
+
+      def returns_a_color
+        return SassC::Script::Value::Color.new(red: 0, green: 0, blue: 0)
+      end
+
+      def returns_a_number
+        return SassC::Script::Value::Number.new(-312,'rem')
+      end
+
+      def returns_a_bool
+        return SassC::Script::Value::Bool.new(true)
+      end
+
+      def inspect_bool ( argument )
+        raise StandardError.new "passed value is not a Sass::Script::Value::Bool" unless argument.is_a? SassC::Script::Value::Bool
+        return argument
+      end
+
+      def inspect_number ( argument )
+        raise StandardError.new "passed value is not a Sass::Script::Value::Number" unless argument.is_a? SassC::Script::Value::Number
+        return argument
+      end
+
+      def inspect_map ( argument )
+        argument.to_h.each_pair do |key, value|
+          raise StandardError.new "key #{key.inspect} is not a string" unless key.is_a? SassC::Script::Value::String
+
+          valueClass = case key.value
+                         when 'string'
+                           SassC::Script::Value::String
+                         when 'number'
+                           SassC::Script::Value::Number
+                         when 'color'
+                           SassC::Script::Value::Color
+                         when 'map'
+                           SassC::Script::Value::Map
+                       end
+
+          raise StandardError.new "unknown key #{key.inspect}" unless valueClass
+          raise StandardError.new "value for #{key.inspect} is not a #{valueClass}" unless value.is_a? valueClass
+        end
+        return argument
+      end
+
+      def inspect_list(argument)
+        raise StandardError.new "passed value is not a Sass::Script::Value::List" unless argument.is_a? SassC::Script::Value::List
+        return argument
+      end
+
+      def returns_sass_value
+        return SassC::Script::Value::Color.new(red: 0, green: 0, blue: 0)
+      end
+
+      def returns_sass_map
+        key = SassC::Script::Value::String.new("color", "string")
+        value = SassC::Script::Value::Color.new(red: 0, green: 0, blue: 0)
+        values = {}
+        values[key] = value
+        map = SassC::Script::Value::Map.new values
+        return map
+      end
+
+      def returns_sass_list
+        numbers = [10, 20, 30].map { |n| SassC::Script::Value::Number.new(n, '') }
+        SassC::Script::Value::List.new(numbers, separator: :space)
+      end
+
+    end
+
+  end
+end

data/test/native_test.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  module NativeTest
+    SAMPLE_SASS_STRING = "$size: 30px; .hi { width: $size; }"
+    SPECIAL_SASS_STRING = "$sißßßßßße: 30px; .hßß©i { width: $size; }"
+    SAMPLE_CSS_OUTPUT = ".hi {\n  width: 30px; }\n"
+    BAD_SASS_STRING = "$size = 30px;"
+
+    class General < MiniTest::Test
+      def test_it_reports_the_libsass_version
+        assert_equal "3.6.0", Native.version
+      end
+    end
+
+    class DataContext < MiniTest::Test
+      def teardown
+        Native.delete_data_context(@data_context) if @data_context
+      end
+
+      def test_compile_status_is_zero_when_successful
+        @data_context = Native.make_data_context(SAMPLE_SASS_STRING)
+        context = Native.data_context_get_context(@data_context)
+
+        status = Native.compile_data_context(@data_context)
+        assert_equal 0, status
+
+        status = Native.context_get_error_status(context)
+        assert_equal 0, status
+      end
+
+      def test_compiled_css_is_correct
+        @data_context = Native.make_data_context(SAMPLE_SASS_STRING)
+        context = Native.data_context_get_context(@data_context)
+        Native.compile_data_context(@data_context)
+
+        css = Native.context_get_output_string(context)
+        assert_equal SAMPLE_CSS_OUTPUT, css
+      end
+
+      def test_compile_status_is_one_if_failed
+        @data_context = Native.make_data_context(BAD_SASS_STRING)
+        context = Native.data_context_get_context(@data_context)
+
+        status = Native.compile_data_context(@data_context)
+        refute_equal 0, status
+
+        status = Native.context_get_error_status(context)
+        refute_equal 0, status
+      end
+
+      def test_multibyte_characters_work
+        @data_context = Native.make_data_context(SPECIAL_SASS_STRING)
+        context = Native.data_context_get_context(@data_context)
+
+        status = Native.compile_data_context(@data_context)
+        refute_equal 0, status
+      end
+
+      def test_custom_function
+        data_context = Native.make_data_context("foo { margin: foo(); }")
+        context = Native.data_context_get_context(data_context)
+        options = Native.context_get_options(context)
+
+        random_thing = FFI::MemoryPointer.from_string("hi")
+
+        funct = FFI::Function.new(:pointer, [:pointer, :pointer]) do |s_args, cookie|
+          Native.make_number(43, "px")
+        end
+
+        callback = Native.make_function(
+          "foo()",
+          funct,
+          random_thing
+        )
+
+        list = Native.make_function_list(1)
+        Native::function_set_list_entry(list, 0, callback);
+        Native::option_set_c_functions(options, list)
+
+        assert_equal Native.option_get_c_functions(options), list
+
+        first_list_entry = Native.function_get_list_entry(list, 0)
+        assert_equal Native.function_get_function(first_list_entry),
+                     funct
+        assert_equal Native.function_get_signature(first_list_entry),
+                     "foo()"
+        assert_equal Native.function_get_cookie(first_list_entry),
+                     random_thing
+
+        string = Native.make_string("hello")
+        assert_equal :sass_string, Native.value_get_tag(string)
+        assert_equal "hello", Native.string_get_value(string)
+
+        number = Native.make_number(123.4, "rem")
+        assert_equal 123.4, Native.number_get_value(number)
+        assert_equal "rem", Native.number_get_unit(number)
+
+        Native.compile_data_context(data_context)
+
+        css = Native.context_get_output_string(context)
+        assert_equal "foo {\n  margin: 43px; }\n", css
+      end
+    end
+
+    class FileContext < MiniTest::Test
+      include TempFileTest
+
+      def teardown
+        Native.delete_file_context(@file_context) if @file_context
+      end
+
+      def test_compile_status_is_zero_when_successful
+        temp_file("style.scss", SAMPLE_SASS_STRING)
+
+        @file_context = Native.make_file_context("style.scss")
+        context = Native.file_context_get_context(@file_context)
+
+        status = Native.compile_file_context(@file_context)
+        assert_equal 0, status
+
+        status = Native.context_get_error_status(context)
+        assert_equal 0, status
+      end
+
+      def test_compiled_css_is_correct
+        temp_file("style.scss", SAMPLE_SASS_STRING)
+
+        @file_context = Native.make_file_context("style.scss")
+        context = Native.file_context_get_context(@file_context)
+        Native.compile_file_context(@file_context)
+
+        css = Native.context_get_output_string(context)
+        assert_equal SAMPLE_CSS_OUTPUT, css
+      end
+
+      def test_invalid_file_name
+        temp_file("style.scss", SAMPLE_SASS_STRING)
+
+        @file_context = Native.make_file_context("style.jajaja")
+        context = Native.file_context_get_context(@file_context)
+        status = Native.compile_file_context(@file_context)
+
+        refute_equal 0, status
+
+        error = Native.context_get_error_message(context)
+
+        assert_match "Error: File to read not found or unreadable: style.jajaja",
+                     error
+      end
+
+      def test_file_import
+        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; }")
+
+        @file_context = Native.make_file_context("styles.scss")
+        context = Native.file_context_get_context(@file_context)
+        status = Native.compile_file_context(@file_context)
+
+        assert_equal 0, status
+
+        css = Native.context_get_output_string(context)
+        assert_equal SAMPLE_CSS_OUTPUT, css
+
+        included_files = Native.context_get_included_files(context)
+        included_files.sort!
+
+        assert_match /import.scss/, included_files[0]
+        assert_match /import_parent.scss/, included_files[1]
+        assert_match /styles.scss/, included_files[2]
+      end
+
+      def test_custom_importer
+        temp_file("not_included.scss", "$size: $var + 25;")
+        temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+
+        @file_context = Native.make_file_context("styles.scss")
+        context = Native.file_context_get_context(@file_context)
+        options = Native.context_get_options(context)
+
+        funct = FFI::Function.new(:pointer, [:pointer, :pointer, :pointer]) do |url, prev, cookie|
+          list = Native.make_import_list(2)
+
+          str = "$var: 5px;\0"
+          data = Native::LibC.malloc(str.size)
+          data.write_string(str)
+
+          entry0 = Native.make_import_entry("fake_includ.scss", data, nil)
+          entry1 = Native.make_import_entry("not_included.scss", nil, nil)
+          Native.import_set_list_entry(list, 0, entry0)
+          Native.import_set_list_entry(list, 1, entry1)
+          list
+        end
+
+        callback = Native.make_importer(funct, nil)
+        list = Native.make_function_list(1)
+        Native::function_set_list_entry(list, 0, callback)
+
+        Native.option_set_c_importers(options, list)
+
+        status = Native.compile_file_context(@file_context)
+        assert_equal 0, status
+
+        css = Native.context_get_output_string(context)
+        assert_equal SAMPLE_CSS_OUTPUT, css
+      end
+    end
+  end
+end

data/test/output_style_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class OutputStyleTest < MiniTest::Test
+    def input_scss
+      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_nested_output
+      <<-CSS
+#main {
+  color: #fff;
+  background-color: #000; }
+  #main p {
+    width: 10em; }
+
+.huge {
+  font-size: 10em;
+  font-weight: bold;
+  text-decoration: underline; }
+      CSS
+    end
+
+    def test_nested_output_is_default
+      engine = Engine.new(input_scss)
+      assert_equal expected_nested_output, engine.render
+    end
+
+    def test_output_style_accepts_strings
+      engine = Engine.new(input_scss, style: 'sass_style_nested')
+      assert_equal expected_nested_output, engine.render
+    end
+
+    def test_invalid_output_style
+      engine = Engine.new(input_scss, style: 'totally_wrong')
+      assert_raises(InvalidStyleError) { engine.render }
+    end
+
+    def test_nested_output
+      engine = Engine.new(input_scss, style: :sass_style_nested)
+      assert_equal expected_nested_output, engine.render
+    end
+
+    def test_expanded_output
+      engine = Engine.new(input_scss, style: :sass_style_expanded)
+      assert_equal <<-CSS, engine.render
+#main {
+  color: #fff;
+  background-color: #000;
+}
+
+#main p {
+  width: 10em;
+}
+
+.huge {
+  font-size: 10em;
+  font-weight: bold;
+  text-decoration: underline;
+}
+      CSS
+    end
+
+    def test_compact_output
+      engine = Engine.new(input_scss, style: :sass_style_compact)
+      assert_equal <<-CSS, engine.render
+#main { color: #fff; background-color: #000; }
+
+#main p { width: 10em; }
+
+.huge { font-size: 10em; font-weight: bold; text-decoration: underline; }
+      CSS
+    end
+
+    def test_compressed_output
+      engine = Engine.new(input_scss, style: :sass_style_compressed)
+      assert_equal <<-CSS, engine.render
+#main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
+      CSS
+    end
+
+    def test_short_output_style_names
+      engine = Engine.new(input_scss, style: :compressed)
+      assert_equal <<-CSS, engine.render
+#main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
+      CSS
+    end
+  end
+end

data/test/sass_2_scss_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class Sass2ScssTest < MiniTest::Test
+    def test_compact_output
+      assert_equal ".blat { color: red; }", Sass2Scss.convert(<<SASS)
+.blat
+  color: red
+SASS
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "minitest/pride"
+require "minitest/around/unit"
+require "test_construct"
+require "pry"
+
+require "sassc"
+
+module FixtureHelper
+  FIXTURE_ROOT = File.expand_path(File.join(File.dirname(__FILE__), "fixtures"))
+
+  def fixture(path)
+    IO.read(fixture_path(path))
+  end
+
+  def fixture_path(path)
+    if path.match(FIXTURE_ROOT)
+      path
+    else
+      File.join(FIXTURE_ROOT, path)
+    end
+  end
+end
+
+module TempFileTest
+  include TestConstruct::Helpers
+
+  def around
+    within_construct do |construct|
+      @construct = construct
+      yield
+    end
+    @construct = nil
+  end
+
+  def temp_file(filename, contents)
+    @construct.file(filename, contents)
+  end
+
+  def temp_dir(directory)
+    @construct.directory(directory)
+  end
+end