sass-embedded 0.1.2 → 0.2.4

data/test/output_style_test.rb

@@ -1,92 +1,92 @@
 # frozen_string_literal: true
 
-require_relative "test_helper"
+require_relative 'test_helper'
 
 module Sass
   class OutputStyleTest < MiniTest::Test
-
     def setup
-      @compiler = Embedded::Compiler.new
+      @embedded = Embedded.new
     end
 
     def teardown
+      @embedded.close
     end
 
     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
+      <<~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_expanded_output
-      <<-CSS.chomp
-#main {
-  color: #fff;
-  background-color: #000;
-}
-#main p {
-  width: 10em;
-}
-
-.huge {
-  font-size: 10em;
-  font-weight: bold;
-  text-decoration: underline;
-}
-CSS
+      <<~CSS.chomp
+        #main {
+          color: #fff;
+          background-color: #000;
+        }
+        #main p {
+          width: 10em;
+        }
+
+        .huge {
+          font-size: 10em;
+          font-weight: bold;
+          text-decoration: underline;
+        }
+      CSS
     end
 
     def test_expanded_output_is_default
-      output = @compiler.render({ data: input_scss })[:css]
+      output = @embedded.render({ data: input_scss })[:css]
       assert_equal expected_expanded_output, output
     end
 
     def test_output_style_accepts_strings
-      output = @compiler.render({ data: input_scss, output_style: :expanded })[:css]
+      output = @embedded.render({ data: input_scss, output_style: :expanded })[:css]
       assert_equal expected_expanded_output, output
     end
 
     def test_invalid_output_style
-      assert_raises(InvalidStyleError) {
-        @compiler.render({ data: input_scss, output_style: :totally_wrong })[:css]
-      }
+      assert_raises(InvalidStyleError) do
+        @embedded.render({ data: input_scss, output_style: :totally_wrong })[:css]
+      end
     end
 
     def test_unsupported_output_style
-      assert_raises(UnsupportedValue) {
-        @compiler.render({ data: input_scss, output_style: :nested })[:css]
-      }
+      assert_raises(UnsupportedValue) do
+        @embedded.render({ data: input_scss, output_style: :nested })[:css]
+      end
 
-      assert_raises(UnsupportedValue) {
-        @compiler.render({ data: input_scss, output_style: :compact })[:css]
-      }
+      assert_raises(UnsupportedValue) do
+        @embedded.render({ data: input_scss, output_style: :compact })[:css]
+      end
     end
 
     def test_compressed_output
-      output = @compiler.render({ data: input_scss, output_style: :compressed })[:css]
-      assert_equal <<-CSS.chomp, output
-#main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
+      output = @embedded.render({ data: input_scss, output_style: :compressed })[:css]
+      assert_equal <<~CSS.chomp, output
+        #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
       CSS
     end
 
     def test_string_output_style_names
-      output = @compiler.render({ data: input_scss, output_style: 'compressed' })[:css]
-      assert_equal <<-CSS.chomp, output
-#main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
+      output = @embedded.render({ data: input_scss, output_style: 'compressed' })[:css]
+      assert_equal <<~CSS.chomp, output
+        #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
       CSS
     end
   end

data/test/sass_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+module Sass
+  class SassTest < MiniTest::Test
+    def test_sass_works
+      assert_equal '', Sass.render({
+                                     data: ''
+                                   })[:css]
+
+      css = <<~CSS.chomp
+        h1 {
+          font-size: 2rem;
+        }
+      CSS
+      assert_equal css, Sass.render({
+                                      data: 'h1 { font-size: 2rem; }'
+                                    })[:css]
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require "minitest/autorun"
-require "minitest/pride"
-require "minitest/around/unit"
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'minitest/around/unit'
 
-require_relative "../lib/sass"
+require_relative '../lib/sass'
 
 module TempFileTest
   def around
@@ -18,7 +18,7 @@ module TempFileTest
   end
 
   def temp_file(filename, contents)
-    File.open(filename, "w",) do |file|
+    File.open(filename, 'w') do |file|
       file.write(contents)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sass-embedded
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.4
 platform: ruby
 authors:
 - なつき
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -94,12 +94,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Use dart-sass with Ruby!
 email:
 - i@ntk.me
 executables: []
 extensions:
-- ext/sass_embedded/extconf.rb
+- ext/extconf.rb
 extra_rdoc_files: []
 files:
 - ".github/workflows/build.yml"
@@ -108,14 +122,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- ext/sass_embedded/.gitignore
-- ext/sass_embedded/Makefile
-- ext/sass_embedded/extconf.rb
+- ext/.gitignore
+- ext/Makefile
+- ext/extconf.rb
 - lib/sass.rb
-- lib/sass/embedded/compiler.rb
-- lib/sass/embedded/transport.rb
+- lib/sass/embedded.rb
 - lib/sass/error.rb
 - lib/sass/platform.rb
+- lib/sass/transport.rb
 - lib/sass/util.rb
 - lib/sass/version.rb
 - sass-embedded.gemspec
@@ -124,6 +138,7 @@ files:
 - test/error_test.rb
 - test/functions_test.rb
 - test/output_style_test.rb
+- test/sass_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ntkme/embedded-host-ruby
 licenses:
@@ -154,4 +169,5 @@ test_files:
 - test/error_test.rb
 - test/functions_test.rb
 - test/output_style_test.rb
+- test/sass_test.rb
 - test/test_helper.rb

data/ext/sass_embedded/Makefile

@@ -1,35 +0,0 @@
-.PHONY: install
-install:
-ifeq ($(OS),Windows_NT)
-	powershell -command "Get-Item sass_embedded-*.zip | Expand-Archive -DestinationPath (Get-Location) -Force"
-	powershell -command "Get-Item protoc-*.zip | Expand-Archive -DestinationPath protoc -Force"
-	./protoc/bin/protoc --ruby_out=. embedded_sass.proto
-else
-	tar -vxzf sass_embedded-*.tar.gz
-	unzip -od protoc protoc-*.zip
-	./protoc/bin/protoc --ruby_out=. embedded_sass.proto
-endif
-
-.PHONY: clean
-clean:
-ifeq ($(OS),Windows_NT)
-	powershell -command "Remove-Item sass_embedded -Recurse -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item protoc -Recurse -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item embedded_sass_pb.rb -Recurse -Force -ErrorAction Ignore"
-else
-	rm -rf sass_embedded
-	rm -rf protoc
-	rm -rf embedded_sass_pb.rb
-endif
-
-.PHONY: distclean
-distclean: clean
-ifeq ($(OS),Windows_NT)
-	powershell -command "Remove-Item sass_embedded-*.zip -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item protoc-*.zip -Force -ErrorAction Ignore"
-	powershell -command "Remove-Item embedded_sass.proto -Force -ErrorAction Ignore"
-else
-	rm -rf sass_embedded-*.tar.gz
-	rm -rf protoc-*.zip
-	rm -rf embedded_sass.proto
-endif

data/ext/sass_embedded/extconf.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/env ruby
-
-require "mkmf"
-require "json"
-require "open-uri"
-require_relative "../../lib/sass/platform"
-
-def api url
-  headers = {}
-  headers["Authorization"] = "token #{ENV["GITHUB_TOKEN"]}" if ENV["GITHUB_TOKEN"]
-  URI.open(url, headers) do |file|
-    JSON.parse file.read
-  end
-end
-
-def download url
-  URI.open(url) do |source|
-    File.open(File.absolute_path(File.basename(url), __dir__), "wb") do |destination|
-      destination.write source.read
-    end
-  end
-end
-
-def download_sass_embedded
-  repo = "sass/dart-sass-embedded"
-
-  release = api("https://api.github.com/repos/#{repo}/releases")[0]['tag_name']
-
-  os = case Sass::Platform::OS
-       when "darwin"
-         "macos"
-       when "linux"
-         "linux"
-       when "windows"
-         "windows"
-       else
-         raise "Unsupported OS: #{Sass::Platform::OS}"
-       end
-
-  arch = case Sass::Platform::ARCH
-         when "x86_64"
-           "x64"
-         when "i386"
-           "ia32"
-         else
-           raise "Unsupported Arch: #{Sass::Platform::ARCH}"
-         end
-
-  ext = case os
-        when "windows"
-          "zip"
-        else
-          "tar.gz"
-        end
-
-  url = "https://github.com/#{repo}/releases/download/#{release}/sass_embedded-#{release}-#{os}-#{arch}.#{ext}"
-
-  begin
-    download url
-  rescue
-    raise "Failed to download: #{url}"
-  end
-end
-
-def download_protoc
-  repo = "protocolbuffers/protobuf"
-
-  tag = URI.open("https://github.com/#{repo}/releases/latest") { |file|
-    File.basename file.base_uri.to_s
-  }
-
-  release = tag[1..-1]
-
-  os = case Sass::Platform::OS
-       when "darwin"
-         "osx"
-       when "linux"
-         "linux"
-       when "windows"
-         "win"
-       else
-         raise "Unsupported OS: #{Sass::Platform::OS}"
-       end
-
-  arch = case Sass::Platform::ARCH
-         when "aarch64"
-           "aarch_64"
-         when "sparcv9"
-           "s390"
-         when "i386"
-           "x86_32"
-         when "x86_64"
-           "x86_64"
-         when "powerpc64"
-           "ppcle_64"
-         else
-           raise "Unsupported Arch: #{Sass::Platform::ARCH}"
-         end
-
-  os_arch = case os
-            when "win"
-              os + arch.split('_').last
-            else
-              os + '-' + arch
-            end
-
-  ext = "zip"
-
-  url = "https://github.com/#{repo}/releases/download/#{tag}/protoc-#{release}-#{os_arch}.#{ext}"
-
-  begin
-    download url
-  rescue
-    raise "Failed to download: #{url}"
-  end
-end
-
-def download_embedded_sass_proto
-  url = "https://raw.githubusercontent.com/sass/embedded-protocol/HEAD/embedded_sass.proto"
-  download url
-end
-
-system("make", "-C", __dir__, "distclean")
-download_sass_embedded
-download_protoc
-download_embedded_sass_proto
-system("make", "-C", __dir__, "install")
-
-File.open(File.absolute_path("sass_embedded.#{RbConfig::CONFIG['DLEXT']}", __dir__), "w") {}
-
-$makefile_created = true

data/lib/sass/embedded/compiler.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-module Sass
-  module Embedded
-    class Compiler
-
-      def initialize
-        if defined? @@pwd
-          if @@pwd == Dir.pwd
-            return
-          else
-            @@transport.close
-          end
-        end
-
-        @@transport = Transport.new
-        @@pwd = Dir.pwd
-
-        @@id_semaphore = Mutex.new
-        @@id = 0
-      end
-
-      def render options
-        start = Sass::Util.now
-
-        if options[:file].nil? && options[:data].nil?
-          raise Sass::NotRenderedError.new 'Either :data or :file must be set.'
-        end
-
-        if options[:file].nil? && Dir.pwd != @@pwd
-          raise Sass::NotRenderedError.new 'Working directory changed after launching `dart-sass-embedded`.'
-        end
-
-        string = options[:data] ? Sass::EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
-          :source => options[:data],
-          :url => options[:file] ? Sass::Util.file_uri(options[:file]) : 'stdin',
-          :syntax => options[:indented_syntax] == true ? Sass::EmbeddedProtocol::Syntax::INDENTED : Sass::EmbeddedProtocol::Syntax::SCSS
-        ) : nil
-
-        path = options[:data] ? nil : options[:file]
-
-        style = case options[:output_style]&.to_sym
-                when :expanded, nil
-                  Sass::EmbeddedProtocol::OutputStyle::EXPANDED
-                when :compressed
-                  Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
-                when :nested, :compact
-                  raise Sass::UnsupportedValue.new "#{options[:output_style]} is not a supported :output_style"
-                else
-                  raise Sass::InvalidStyleError.new "#{options[:output_style]} is not a valid :output_style"
-                end
-
-        source_map = options[:source_map].is_a? String || (options[:source_map] == true && !!options[:out_file])
-
-        # 1. Loading a file relative to the file in which the @use or @import appeared.
-        # 2. Each custom importer.
-        # 3. Loading a file relative to the current working directory.
-        # 4. Each load path in includePaths
-        # 5. Each load path specified in the SASS_PATH environment variable, which should be semicolon-separated on Windows and colon-separated elsewhere.
-        importers = (options[:importer] ? [
-          Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new( :importer_id => 0 )
-        ] : []).concat(
-          (options[:include_paths] || []).concat(Sass.include_paths)
-          .map { |path| Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
-            :path => File.absolute_path(path)
-          )}
-        )
-
-        signatures = []
-        functions = {}
-        options[:functions]&.each { |signature, function|
-          signatures.push signature
-          functions[signature.to_s.split('(')[0].chomp] = function
-        }
-
-        compilation_id = next_id
-
-        compile_request = Sass::EmbeddedProtocol::InboundMessage::CompileRequest.new(
-          :id               => compilation_id,
-          :string           => string,
-          :path             => path,
-          :style            => style,
-          :source_map       => source_map,
-          :importers        => importers,
-          :global_functions => options[:functions] ? signatures : [],
-          :alert_color      => true,
-          :alert_ascii      => true
-        )
-
-        response = @@transport.send compile_request, compilation_id
-
-        file = options[:file] || 'stdin'
-        canonicalizations = {}
-        imports = {}
-
-        loop do
-          case response
-          when Sass::EmbeddedProtocol::OutboundMessage::CompileResponse
-            break
-          when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
-            url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
-
-            if canonicalizations.has_key? url
-              canonicalizations[url].id = response.id
-            else
-              resolved = nil
-              options[:importer].each { |importer|
-                begin
-                  resolved = importer.call response.url, file
-                rescue Exception => error
-                  resolved = error
-                end
-                break if resolved
-              }
-              if resolved.nil?
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => url
-                )
-              elsif resolved.is_a? Exception
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id    => response.id,
-                  :error => resolved.message
-                )
-              elsif resolved.has_key? :contents
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => url
-                )
-                imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                  :id      => response.id,
-                  :success => Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                    :contents       => resolved[:contents],
-                    :syntax         => Sass::EmbeddedProtocol::Syntax::SCSS,
-                    :source_map_url => nil
-                  )
-                )
-              elsif resolved.has_key? :file
-                canonicalized_url = Sass::Util.file_uri(resolved[:file])
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => canonicalized_url
-                )
-                imports[canonicalized_url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                  :id      => response.id,
-                  :success => Sass::EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
-                    :contents       => File.read(resolved[:file]),
-                    :syntax         => Sass::EmbeddedProtocol::Syntax::SCSS,
-                    :source_map_url => nil
-                  )
-                )
-              else
-                canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id    => response.id,
-                  :error => "Unexpected value returned from importer: #{resolved}"
-                )
-              end
-            end
-
-            response = @@transport.send canonicalizations[url], compilation_id
-          when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
-            url = response.url
-
-            if imports.has_key? url
-              imports[url].id = response.id
-            else
-              imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                :id    => response.id,
-                :error => "Failed to import: #{url}"
-              )
-            end
-
-            response = @@transport.send imports[url], compilation_id
-          when Sass::EmbeddedProtocol::OutboundMessage::FunctionCallRequest
-            begin
-              message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-                :id      => response.id,
-                :success => functions[response.name].call(*response.arguments)
-              )
-            rescue Exception => error
-              message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-                :id    => response.id,
-                :error => error.message
-              )
-            end
-
-            response = @@transport.send message, compilation_id
-          when Sass::EmbeddedProtocol::ProtocolError
-            raise Sass::ProtocolError.new response.message
-          else
-            raise Sass::ProtocolError.new "Unexpected packet received: #{response}"
-          end
-        end
-
-        if response.failure
-          raise Sass::CompilationError.new(
-            response.failure.message,
-            response.failure.formatted,
-            response.failure.span ? response.failure.span.url : nil,
-            response.failure.span ? response.failure.span.start.line + 1 : nil,
-            response.failure.span ? response.failure.span.start.column + 1 : nil,
-            1
-          )
-        end
-
-        finish = Sass::Util.now
-
-        return {
-          css: response.success.css,
-          map: response.success.source_map,
-          stats: {
-            entry: options[:file] || 'data',
-            start: start,
-            end: finish,
-            duration: finish - start
-          }
-        }
-      end
-
-      private
-
-      def info
-        version_response = @@transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
-          :id => next_id
-        )
-        return {
-          compiler_version: version_response.compiler_version,
-          protocol_version: version_response.protocol_version,
-          implementation_name: version_response.implementation_name,
-          implementation_version: version_response.implementation_version
-        }
-      end
-
-      def next_id
-        @@id_semaphore.synchronize {
-          @@id += 1
-          if @@id == Transport::PROTOCOL_ERROR_ID
-            @@id = 0
-          end
-          @@id
-        }
-      end
-
-      def restart
-        @@transport.close
-        @@transport = Transport.new
-      end
-    end
-  end
-end