sass-embedded 0.1.0

data/lib/sass/embedded/transport.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "open3"
+require "observer"
+require_relative "../../../ext/sass_embedded/embedded_sass_pb.rb"
+
+module Sass
+  module Embedded
+    class Transport
+
+      include Observable
+
+      DART_SASS_EMBEDDED = File.absolute_path("../../../ext/sass_embedded/sass_embedded/dart-sass-embedded#{Sass::Platform::OS == 'windows' ? '.bat' : ''}", __dir__)
+
+      PROTOCOL_ERROR_ID = 4294967295
+
+      def initialize
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(DART_SASS_EMBEDDED)
+        @stdin_semaphore = Mutex.new
+        @observerable_semaphore = Mutex.new
+
+        Thread.new do
+          loop do
+            begin
+              bits = length = 0
+              loop do
+                byte = @stdout.readbyte
+                length += (byte & 0x7f) << bits
+                bits += 7
+                break if byte <= 0x7f
+              end
+              changed
+              payload = @stdout.read length
+              @observerable_semaphore.synchronize {
+                notify_observers nil, Sass::EmbeddedProtocol::OutboundMessage.decode(payload)
+              }
+            rescue Interrupt
+              break
+            rescue IOError, EOFError => error
+              notify_observers error, nil
+              close
+              break
+            end
+          end
+        end
+
+        Thread.new do
+          loop do
+            begin
+              $stderr.puts @stderr.read
+            rescue Interrupt
+              break
+            rescue IOError, EOFErrorr => error
+              @observerable_semaphore.synchronize {
+                notify_observers error, nil
+              }
+              close
+              break
+            end
+          end
+        end
+      end
+
+      def send req, id
+        mutex = Mutex.new
+        resource = ConditionVariable.new
+
+        req_name = req.class.name.split('::').last.gsub(/\B(?=[A-Z])/, "_").downcase
+
+        message = Sass::EmbeddedProtocol::InboundMessage.new(req_name.to_sym => req)
+
+        error = nil
+        res = nil
+
+        @observerable_semaphore.synchronize {
+          MessageObserver.new self, id do |_error, _res|
+            mutex.synchronize {
+              error = _error
+              res = _res
+
+              resource.signal
+            }
+          end
+        }
+
+        mutex.synchronize {
+          write message.to_proto
+
+          resource.wait(mutex)
+        }
+
+        raise error if error
+        res
+      end
+
+      def close
+        begin
+          delete_observers
+          @stdin.close
+          @stdout.close
+          @stderr.close
+        rescue
+        end
+      end
+
+      private
+
+      def write proto
+        @stdin_semaphore.synchronize {
+          length = proto.length
+          while length > 0
+            @stdin.write ((length > 0x7f ? 0x80 : 0) | (length & 0x7f)).chr
+            length >>= 7
+          end
+          @stdin.write proto
+        }
+      end
+    end
+
+    private
+
+    class MessageObserver
+      def initialize obs, id, &block
+        @obs = obs
+        @id = id
+        @block = block
+        @obs.add_observer self
+      end
+
+      def update error, message
+        if error
+          @obs.delete_observer self
+          @block.call error, nil
+        elsif message.error&.id == Sass::Embedded::Transport::PROTOCOL_ERROR_ID
+          @obs.delete_observer self
+          @block.call Sass::ProtocolError.new(message.error.message), nil
+        else
+          res = message[message.message.to_s]
+          if (res['compilation_id'] == @id || res['id'] == @id)
+            @obs.delete_observer self
+            @block.call error, res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sass/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sass
+
+  class BaseError < StandardError; end
+  class ProtocolError < BaseError; end
+  class NotRenderedError < BaseError; end
+  class InvalidStyleError < BaseError; end
+  class UnsupportedValue < BaseError; end
+
+  class CompilationError < BaseError
+
+    attr_accessor :formatted, :file, :line, :column, :status
+
+    def initialize(message, formatted, file, line, column, status)
+      @formatted = formatted
+      @file = file
+      @line = line
+      @column = column
+      @status = status
+      super(message)
+    end
+
+    def backtrace
+      return nil if super.nil?
+      ["#{@file}:#{@line}:#{@column}"] + super
+    end
+  end
+end

data/lib/sass/platform.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+
+
+module Sass
+  module Platform
+
+    OS = case RbConfig::CONFIG['host_os'].downcase
+         when /linux/
+           "linux"
+         when /darwin/
+           "darwin"
+         when /freebsd/
+           "freebsd"
+         when /netbsd/
+           "netbsd"
+         when /openbsd/
+           "openbsd"
+         when /dragonfly/
+           "dragonflybsd"
+         when /sunos|solaris/
+           "solaris"
+         when /mingw|mswin/
+           "windows"
+         else
+           RbConfig::CONFIG['host_os'].downcase
+         end
+
+    OSVERSION = RbConfig::CONFIG['host_os'].gsub(/[^\d]/, '').to_i
+
+    CPU = RbConfig::CONFIG['host_cpu']
+
+    ARCH = case CPU.downcase
+           when /amd64|x86_64|x64/
+             "x86_64"
+           when /i\d86|x86|i86pc/
+             "i386"
+           when /ppc64|powerpc64/
+             "powerpc64"
+           when /ppc|powerpc/
+             "powerpc"
+           when /sparcv9|sparc64/
+             "sparcv9"
+           when /arm64|aarch64/  # MacOS calls it "arm64", other operating systems "aarch64"
+             "aarch64"
+           when /^arm/
+             if OS == "darwin"   # Ruby before 3.0 reports "arm" instead of "arm64" as host_cpu on darwin
+               "aarch64"
+             else
+               "arm"
+             end
+           else
+             RbConfig::CONFIG['host_cpu']
+           end
+  end
+end

data/lib/sass/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sass
+  module Util
+    extend self
+
+    def file_uri path
+      absolute_path = File.absolute_path(path)
+
+      if !absolute_path.start_with?('/')
+        components = absolute_path.split File::SEPARATOR
+        components[0] = components[0].split(':').first.downcase
+        absolute_path = components.join File::SEPARATOR
+      end
+
+      'file://' + absolute_path
+    end
+
+    def now
+      (Time.now.to_f * 1000).to_i
+    end
+  end
+end

data/lib/sass/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Sass
+  VERSION = "0.1.0"
+end
+

data/sass-embedded.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sass/version"
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "sass-embedded"
+  spec.version       = Sass::VERSION
+  spec.authors       = ["なつき"]
+  spec.email         = ["i@ntk.me"]
+  spec.summary       = "Use dart-sass with Ruby!"
+  spec.description   = "Use dart-sass with Ruby!"
+  spec.homepage      = "https://github.com/ntkme/embedded-host-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.extensions    = ['ext/sass_embedded/extconf.rb']
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.require_paths = ["lib"]
+
+  spec.platform      = Gem::Platform::RUBY
+
+  spec.add_dependency "google-protobuf", "~> 3.17.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "minitest", "~> 5.14.4"
+  spec.add_development_dependency "minitest-around"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+end

data/test/compiler_test.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module Sass
+  class CompilerTest < MiniTest::Test
+    include TempFileTest
+
+    def setup
+      @compiler = Embedded::Compiler.new
+    end
+
+    def teardown
+    end
+
+    def render(data)
+      @compiler.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 = @compiler.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 = @compiler.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 = @compiler.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 = @compiler.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}", @compiler.render({
+        data: File.read("styles.scss"),
+        include_paths: [ "included_1", "included_2" ]
+      })[:css]
+    end
+
+    def test_global_include_paths
+      skip 'race condition in test'
+
+      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'; $size: $s;")
+      temp_file("styles.scss", "@use 'import.scss'; .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
+      skip 'race condition in test'
+
+      expected_include_paths = [ "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'; $size: $s;")
+      temp_file("styles.scss", "@use 'import.scss'; .hi { width: $size; }")
+
+      assert_raises(CompilationError) 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, @compiler.render({ data: sass, indented_syntax: true })[:css]
+      assert_raises(CompilationError) do
+        @compiler.render({ data: sass, indented_syntax: false })
+      end
+    end
+
+    def test_inline_source_maps
+      skip 'not supported'
+
+      template = <<-SCSS
+.foo {
+  baz: bang; }
+      SCSS
+      expected_output = <<-CSS
+/* line 1, stdin */
+.foo {
+  baz: bang; }
+      CSS
+
+      output = @compiler.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 = @compiler.render({
+              data: "div { width: #{id} }",
+            })[:css]
+            assert_match /#{id}/, output
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+  end
+end