piko-fast-gem 0.0.1

data/sassc-2.4.0/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/sassc-2.4.0/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/sassc-2.4.0/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"));
+}

data/sassc-2.4.0/test/functions_test.rb

@@ -0,0 +1,340 @@
+# 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_match /\[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
+
+    def test_concurrency
+      10.times do
+        threads = []
+        10.times do |i|
+          threads << Thread.new(i) do |id|
+            out = Engine.new("div { url: inspect_options(); }", {test_key1: 'test_value', test_key2: id}).render
+            assert_match /test_key1/, out
+            assert_match /test_key2/, out
+            assert_match /test_value/, out
+            assert_match /#{id}/, out
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+
+    def test_pass_custom_functions_as_a_parameter
+      out = Engine.new("div { url: test-function(); }", {functions: ExternalFunctions}).render
+      assert_match /custom_function/, out
+    end
+
+    def test_pass_incompatible_type_to_custom_functions
+      assert_raises(TypeError) do
+        Engine.new("div { url: test-function(); }", {functions: Class.new}).render
+      end
+    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 inspect_options
+        SassC::Script::Value::String.new(self.options.inspect, :string)
+      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
+
+    module ExternalFunctions
+      def test_function
+        SassC::Script::Value::String.new("custom_function", :string)
+      end
+    end
+
+  end
+end