sass-embedded 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d0da205f0cb44177b737a82ce4addac1c94afe4da4a43327963d11feda1fe75
+  data.tar.gz: 9821f8807b4eb6b0c612391628d341d416f96df3d3344eeaa762d88d8bbb9f6d
+SHA512:
+  metadata.gz: ef2437a502053cdae299f97e9e96b28402d9cdb07c8c40454f9666ccdbe66fc7aa20c17fe629978021e3c4a86d91512c112e04b85a144604fd7ba79992081663
+  data.tar.gz: af805efa9a30ca83af3e152cb30b0a72649071e9fd2d2f08ea968a4eedab170c02367c2a5afed84156b4c29e71294e8b9be3bb79371ef8388436fe71adb8ea2e

data/.github/workflows/build.yml

@@ -0,0 +1,47 @@
+name: build
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Download dart-sass-embedded
+      run: bundle exec rake download
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Test
+      run: bundle exec rake
+
+    - name: Build Gem
+      run: rake build
+
+    - name: Install Gem
+      run: rake install
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Test Gem
+      run: |-
+        ruby -r sass -e "puts Sass.render({ data: 'h1 { color: black; }' })[:css]"

data/.gitignore

@@ -0,0 +1,45 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+/Gemfile.lock
+/.ruby-version
+/.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2021, なつき
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,19 @@
+# Embedded Sass Host for Ruby
+
+This is a Ruby library that implements the host side of the [Embedded Sass protocol](https://github.com/sass/sass-embedded-protocol).
+
+It exposes a Ruby API for Sass that's backed by a native [Dart Sass](https://sass-lang.com/dart-sass) executable.
+
+## Usage
+
+``` ruby
+require "sass"
+
+Sass.render({
+  file: "style.scss"
+})
+```
+
+---
+
+Disclaimer: this is not an official Google product.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+
+task default: :test
+
+desc 'Download dart-sass-embedded'
+task :download do
+  require_relative 'ext/sass_embedded/extconf'
+end
+
+desc 'Run all tests'
+task :test do
+  $LOAD_PATH.unshift('lib', 'test')
+  Dir.glob('./test/**/*_test.rb') { |f| require f }
+end

data/ext/sass_embedded/.gitignore

@@ -0,0 +1,2 @@
+/sass_embedded*
+/embedded_sass_pb.*

data/ext/sass_embedded/Makefile

@@ -0,0 +1,23 @@
+.PHONY: install
+install:
+ifeq ($(OS),Windows_NT)
+	powershell -command "Get-Item *.zip | Expand-Archive -DestinationPath (Get-Location) -Force"
+else
+	tar -vxzf *.tar.gz
+endif
+
+.PHONY: clean
+clean:
+ifeq ($(OS),Windows_NT)
+	powershell -command "Remove-Item sass_embedded -Recurse -Force -ErrorAction Ignore"
+else
+	rm -rf sass_embedded
+endif
+
+.PHONY: distclean
+distclean: clean
+ifeq ($(OS),Windows_NT)
+	powershell -command "Remove-Item sass_embedded-*.zip -Force -ErrorAction Ignore"
+else
+	rm -rf sass_embedded-*.tar.gz
+endif

data/ext/sass_embedded/extconf.rb

@@ -0,0 +1,72 @@
+#!/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
+
+system("make", "-C", __dir__, "distclean")
+download_sass_embedded
+system("make", "-C", __dir__, "install")
+
+File.open(File.absolute_path("sass_embedded.#{RbConfig::CONFIG['DLEXT']}", __dir__), "w") {}
+
+$makefile_created = true

data/lib/sass.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Sass
+  # The global include_paths for Sass files. This is meant for plugins and
+  # libraries to register the paths to their Sass stylesheets to that they may
+  # be `@imported`. This includes path is used by every instance of
+  # {Sass::Embedded::Compiler}. They are lower-precedence than any includes
+  # paths passed in via the `:includes_paths` option.
+  #
+  # If the `SASS_PATH` environment variable is set,
+  # the initial value of `include_paths` will be initialized based on that.
+  # The variable should be a colon-separated list of path names
+  # (semicolon-separated on Windows).
+  #
+  # @example
+  #   Sass.include_paths << File.dirname(__FILE__ + '/sass')
+  # @return [Array<String, Pathname>]
+  def self.include_paths
+    @includes_paths ||= if ENV['SASS_PATH']
+                      ENV['SASS_PATH'].split(File::PATH_SEPARATOR)
+                    else
+                      []
+                    end
+  end
+
+  def self.render options
+    @compiler ||= Sass::Embedded::Compiler.new
+    @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"

data/lib/sass/embedded/compiler.rb

@@ -0,0 +1,250 @@
+# 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(
+          Sass.include_paths.concat(options[: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