sass-embedded 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8152265aec1c4adf4ec89b826191a97f202b14bf86cf4093e679f8c24cd2d5af
-  data.tar.gz: 7b0d5d870ed38bf59562f617ad75cf2a3085704e0cc802989d21e15e9f14ee9b
+  metadata.gz: 2c42f58b6f4f3200d3033fd59e65e7cd33132731ab4520bafb2a375cf55577ec
+  data.tar.gz: 2da13b64dab78a0b3fccd9a90cfcc6bd5affcd09dfe0b978aed53b69b2afa51e
 SHA512:
-  metadata.gz: 0d037a1fe518298f2976d99d947544642325fa763315e539115422fb78b0f185d35f6c3b97cb97ec373ae04b70984f772f3915ec35974a450095e1f5f3366d88
-  data.tar.gz: 3844e6926954c302259f55a609e2e63a971c472580026ada05d13753dbebb4fb7bc4a13299c47b93a643b9fceaf742063e8a8b7b78f4ae541408eb4041e877b0
+  metadata.gz: d484872bd432f0092e67f699b18af1e242c982ff0e2019f9d23340593744ca58a015f5d63c76ae83d0a29e05ed362a2015f8f55bdbe472da67488e99c1cdaa8f
+  data.tar.gz: bd452474519dabcd9d793205d8f0dcc64482a5313d48d9eda4464f0a5d6ed8b9d6a34ea1c57e4a8f178beafb008b080481fd6059ab2f3ad53494e2acd272527b

data/.github/workflows/build.yml

@@ -34,9 +34,6 @@ jobs:
     - name: Test
       run: bundle exec rake
 
-    - name: Build Gem
-      run: rake build
-
     - name: Install Gem
       run: rake install
       env:

data/Gemfile

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 gemspec

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 
 task default: :test
@@ -10,5 +12,5 @@ end
 desc 'Run all tests'
 task :test do
   $LOAD_PATH.unshift('lib', 'test')
-  Dir.glob('./test/**/*_test.rb') { |f| require f }
+  Dir.glob('./test/**/*_test.rb').sort.each { |f| require f }
 end

data/ext/sass_embedded/extconf.rb

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

data/lib/sass.rb

@@ -23,15 +23,20 @@ module Sass
                        end
   end
 
-  def self.render options
-    @compiler ||= Sass::Embedded::Compiler.new
+  def self.render(options)
+    unless defined? @compiler
+      @compiler = Sass::Embedded::Compiler.new
+      at_exit do
+        @compiler.close
+      end
+    end
     @compiler.render options
   end
 end
 
-require_relative "sass/version"
-require_relative "sass/error"
-require_relative "sass/platform"
-require_relative "sass/util"
-require_relative "sass/embedded/transport"
-require_relative "sass/embedded/compiler"
+require_relative 'sass/version'
+require_relative 'sass/error'
+require_relative 'sass/platform'
+require_relative 'sass/util'
+require_relative 'sass/embedded/transport'
+require_relative 'sass/embedded/compiler'

data/lib/sass/embedded/compiler.rb

@@ -3,39 +3,24 @@
 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
+        @transport = Transport.new
+        @id_semaphore = Mutex.new
+        @id = 0
       end
 
-      def render options
+      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
+        raise Sass::NotRenderedError, 'Either :data or :file must be set.' if options[:file].nil? && options[:data].nil?
 
-        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
+        string = if 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
+                   )
+                 end
 
         path = options[:data] ? nil : options[:file]
 
@@ -45,49 +30,55 @@ module Sass
                 when :compressed
                   Sass::EmbeddedProtocol::OutputStyle::COMPRESSED
                 when :nested, :compact
-                  raise Sass::UnsupportedValue.new "#{options[:output_style]} is not a supported :output_style"
+                  raise Sass::UnsupportedValue, "#{options[:output_style]} is not a supported :output_style"
                 else
-                  raise Sass::InvalidStyleError.new "#{options[:output_style]} is not a valid :output_style"
+                  raise Sass::InvalidStyleError, "#{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])
+        source_map = options[:source_map].is_a?(String) || (options[:source_map] == true && !options[:out_file].nil?)
 
         # 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)
-          )}
-        )
+        importers = (if options[:importer]
+                       [
+                         Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(importer_id: 0)
+                       ]
+                     else
+                       []
+                     end).concat(
+                       (options[:include_paths] || []).concat(Sass.include_paths)
+                       .map do |include_path|
+                         Sass::EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+                           path: File.absolute_path(include_path)
+                         )
+                       end
+                     )
 
         signatures = []
         functions = {}
-        options[:functions]&.each { |signature, function|
+        options[:functions]&.each do |signature, function|
           signatures.push signature
           functions[signature.to_s.split('(')[0].chomp] = function
-        }
+        end
 
         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
+          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
+        response = @transport.send compile_request, compilation_id
 
         file = options[:file] || 'stdin'
         canonicalizations = {}
@@ -100,95 +91,95 @@ module Sass
           when Sass::EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
             url = Sass::Util.file_uri(File.absolute_path(response.url, File.dirname(file)))
 
-            if canonicalizations.has_key? url
+            if canonicalizations.key? url
               canonicalizations[url].id = response.id
             else
               resolved = nil
-              options[:importer].each { |importer|
+              options[:importer].each do |importer|
                 begin
                   resolved = importer.call response.url, file
-                rescue Exception => error
-                  resolved = error
+                rescue StandardError => e
+                  resolved = e
                 end
                 break if resolved
-              }
+              end
               if resolved.nil?
                 canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => url
+                  id: response.id,
+                  url: url
                 )
-              elsif resolved.is_a? Exception
+              elsif resolved.is_a? StandardError
                 canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id    => response.id,
-                  :error => resolved.message
+                  id: response.id,
+                  error: resolved.message
                 )
-              elsif resolved.has_key? :contents
+              elsif resolved.key? :contents
                 canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => url
+                  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
+                  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
+              elsif resolved.key? :file
                 canonicalized_url = Sass::Util.file_uri(resolved[:file])
                 canonicalizations[url] = Sass::EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
-                  :id  => response.id,
-                  :url => canonicalized_url
+                  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
+                  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}"
+                  id: response.id,
+                  error: "Unexpected value returned from importer: #{resolved}"
                 )
               end
             end
 
-            response = @@transport.send canonicalizations[url], compilation_id
+            response = @transport.send canonicalizations[url], compilation_id
           when Sass::EmbeddedProtocol::OutboundMessage::ImportRequest
             url = response.url
 
-            if imports.has_key? url
+            if imports.key? url
               imports[url].id = response.id
             else
               imports[url] = Sass::EmbeddedProtocol::InboundMessage::ImportResponse.new(
-                :id    => response.id,
-                :error => "Failed to import: #{url}"
+                id: response.id,
+                error: "Failed to import: #{url}"
               )
             end
 
-            response = @@transport.send imports[url], compilation_id
+            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)
+                id: response.id,
+                success: functions[response.name].call(*response.arguments)
               )
-            rescue Exception => error
+            rescue StandardError => e
               message = Sass::EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
-                :id    => response.id,
-                :error => error.message
+                id: response.id,
+                error: e.message
               )
             end
 
-            response = @@transport.send message, compilation_id
+            response = @transport.send message, compilation_id
           when Sass::EmbeddedProtocol::ProtocolError
-            raise Sass::ProtocolError.new response.message
+            raise Sass::ProtocolError, response.message
           else
-            raise Sass::ProtocolError.new "Unexpected packet received: #{response}"
+            raise Sass::ProtocolError, "Unexpected packet received: #{response}"
           end
         end
 
@@ -205,7 +196,7 @@ module Sass
 
         finish = Sass::Util.now
 
-        return {
+        {
           css: response.success.css,
           map: response.success.source_map,
           stats: {
@@ -217,13 +208,17 @@ module Sass
         }
       end
 
+      def close
+        @transport.close
+      end
+
       private
 
       def info
-        version_response = @@transport.send Sass::EmbeddedProtocol::InboundMessage::VersionRequest.new(
-          :id => next_id
+        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,
@@ -232,18 +227,11 @@ module Sass
       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
+        @id_semaphore.synchronize do
+          @id += 1
+          @id = 0 if @id == Transport::PROTOCOL_ERROR_ID
+          @id
+        end
       end
     end
   end