dartsass-ruby 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a89dda4fd651f7a90dc3bfb03ef4aeebb279f5e92ea2b99c970af0f88e3e5290
+  data.tar.gz: 18acbc815964dc76364673e62fde9349c06a0c81731a74ea2932e68c0c047072
+SHA512:
+  metadata.gz: d0ba7bb44579c5a661894debb768fab28b4a5d9f1febe88a1f4d4a2565863e7956554d36d38b7037eb9329605571e322af6f728254b4ecdea88e880d80a333d0
+  data.tar.gz: d12ae55b2e363cdca014d8b04fb29324ca69b2114951738117b15259d63877e8f11b23b99ea6942e192ae3c451b7b29387c22676adc96a3c2ec7ce012d6c6ce8

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) Ryan Boland & Contributors
+Copyright (c) Natsuki
+Copyright (c) TableCheck
+
+MIT License
+
+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,83 @@
+# Dart Sass for Ruby
+
+[![build](https://github.com/tablecheck/dartsass-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/tablecheck/dartsass-ruby/actions/workflows/build.yml)
+[![gem](https://badge.fury.io/rb/dartsass-ruby.svg)](https://rubygems.org/gems/dartsass-ruby)
+
+Use [dart-sass](https://sass-lang.com/dart-sass) with Ruby and Sprockets.
+
+This gem is a fork of [sass/sassc-ruby](https://github.com/sass/sassc-ruby)
+which maintains API compatibility but delegates to the
+[sass-embedded gem](https://github.com/ntkme/sass-embedded-host-ruby)
+which provides native binaries for Dart Sass (instead of the libsass
+C implmentation.)
+
+For ease of upgrading, the root namespace `::SassC` is still used by this gem,
+although it is now a misnomer. This is planned to be migrated in a future
+major version.
+
+### Upgrading to Dart Sass
+
+The interface of [sassc-ruby](https://github.com/sass/sassc-ruby) is largely unchanged, however:
+
+1. Option `style: :nested` and `style: :compact` behave as `style: :expanded`. Use `style: :compressed` for minification.
+2. Option `:precision` is ignored.
+3. Option `:line_comments` is ignored.
+4. `Sass2Scss` functionality has been removed.
+
+See [the dart-sass documentation](https://github.com/sass/dart-sass#behavioral-differences-from-ruby-sass) for other differences.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dartsass-ruby'
+```
+
+Rails/Sprockets users should additionally add [sassc-rails](https://github.com/sass/sassc-rails):
+
+```ruby
+gem 'sassc-rails'
+```
+
+## Usage
+
+This library utilizes [dart-sass](https://github.com/sass/dart-sass) to compile
+SCSS or SASS syntax to CSS. To compile, use a `SassC::Engine`, e.g.:
+
+```ruby
+SassC::Engine.new(".klass1, .klass2 { color: :red; }", style: :compressed).render
+```
+
+## Alternatives
+
+* [dartsass-rails](https://github.com/rails/dartsass-rails): Rails organization
+maintains its own wrapper for Dart Sass. Unlike this gem, dartsass-rails does
+not support Sprockets.
+
+## Credits
+
+* This gem is maintained and used in production by [TableCheck](https://www.tablecheck.com/en/join). (We'd be very glad if the Sass organization could take over maintainership in the future!)
+* Kudos to [@ntkme](https://github.com/ntkme) for dart-sass support.
+* Credit to [Ryan Boland](https://ryanboland.com) and the authors of the original sassc-rails gem.
+* See our [awesome contributors](https://github.com/tablecheck/sassc-ruby/graphs/contributors).
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+### Project Setup
+
+1. Clone repo
+1. Install dependencies - `bundle install`
+1. Run the tests - `bundle exec rake test`
+
+### Code Changes
+
+1. Fork it ([https://github.com/sass/sassc-ruby/fork](https://github.com/sass/sassc-ruby/fork))
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`) - try to include tests
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/dartsass-ruby.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "sassc"

data/lib/sassc/dependency.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SassC
+  class Dependency
+    attr_reader :filename
+    attr_reader :options
+
+    def initialize(filename)
+      @filename = filename
+      @options = { filename: @filename }
+    end
+
+    def self.from_filenames(filenames)
+      filenames.map { |f| new(f) }
+    end
+  end
+end

data/lib/sassc/engine.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module SassC
+  class Engine
+    OUTPUT_STYLES = %i[
+      sass_style_nested
+      sass_style_expanded
+      sass_style_compact
+      sass_style_compressed
+    ]
+
+    attr_reader :template, :options
+
+    def initialize(template, options = {})
+      @template = template
+      @options = options
+      @functions = options.fetch(:functions, Script::Functions)
+    end
+
+    def render
+      return @template.dup if @template.empty?
+
+      result = ::Sass.compile_string(
+        @template,
+        importer: import_handler.setup(nil),
+        load_paths: load_paths,
+        syntax: syntax,
+        url: file_url,
+
+        charset: @options.fetch(:charset, true),
+        source_map: source_map_embed? || !source_map_file.nil?,
+        source_map_include_sources: source_map_contents?,
+        style: output_style,
+
+        functions: functions_handler.setup(nil, functions: @functions),
+        importers: @options.fetch(:importers, []),
+
+        alert_ascii: @options.fetch(:alert_ascii, false),
+        alert_color: @options.fetch(:alert_color, nil),
+        logger: @options.fetch(:logger, nil),
+        quiet_deps: @options.fetch(:quiet_deps, false),
+        verbose: @options.fetch(:verbose, false)
+      )
+
+      @dependencies = result.loaded_urls
+                            .filter { |url| url.start_with?(Protocol::FILE) && url != file_url }
+                            .map { |url| URL.file_url_to_path(url) }
+      @source_map = post_process_source_map(result.source_map)
+
+      return post_process_css(result.css) unless quiet?
+    rescue ::Sass::CompileError => e
+      line = e.span&.start&.line
+      line += 1 unless line.nil?
+      url = e.span&.url
+      path = (URL.parse(url).route_from(URL.path_to_file_url("#{Dir.pwd}/")) if url&.start_with?(Protocol::FILE))
+      raise SyntaxError.new(e.full_message, filename: path, line: line)
+    end
+
+    def dependencies
+      raise NotRenderedError unless @dependencies
+      Dependency.from_filenames(@dependencies)
+    end
+
+    def source_map
+      raise NotRenderedError unless @source_map
+      @source_map
+    end
+
+    def filename
+      @options[:filename]
+    end
+
+    private
+
+    def quiet?
+      @options[:quiet]
+    end
+
+    def precision
+      @options[:precision]
+    end
+
+    def sass?
+      @options[:syntax] && @options[:syntax].to_sym == :sass
+    end
+
+    def line_comments?
+      @options[:line_comments]
+    end
+
+    def source_map_embed?
+      @options[:source_map_embed]
+    end
+
+    def source_map_contents?
+      @options[:source_map_contents]
+    end
+
+    def omit_source_map_url?
+      @options[:omit_source_map_url]
+    end
+
+    def source_map_file
+      @options[:source_map_file]
+    end
+
+    def validate_source_map_path?
+      @options.fetch(:validate_source_map_path, true)
+    end
+
+    def import_handler
+      @import_handler ||= ImportHandler.new(@options)
+    end
+
+    def functions_handler
+      @functions_handler = FunctionsHandler.new(@options)
+    end
+
+    def file_url
+      @file_url ||= URL.path_to_file_url(File.absolute_path(filename || 'stdin'))
+    end
+
+    def output_path
+      @output_path ||= @options.fetch(
+        :output_path,
+        ("#{filename.delete_suffix(File.extname(filename))}.css" if filename)
+      )
+    end
+
+    def output_url
+      @output_url ||= (URL.path_to_file_url(File.absolute_path(output_path)) if output_path)
+    end
+
+    def source_map_file_url
+      return unless source_map_file
+      @source_map_file_url ||=
+        if validate_source_map_path?
+          URL.path_to_file_url(File.absolute_path(source_map_file))
+        else
+          source_map_file
+        end
+    end
+
+    def output_style_enum
+      @output_style_enum ||= Native::SassOutputStyle[output_style]
+    end
+
+    def output_style
+      @output_style ||= begin
+                          style = @options.fetch(:style, :sass_style_nested).to_s
+                          style = "sass_style_#{style}" unless style.include?('sass_style_')
+                          raise InvalidStyleError unless OUTPUT_STYLES.include?(style.to_sym)
+
+                          style = style.delete_prefix('sass_style_').to_sym
+                          case style
+                          when :nested, :compact
+                            :expanded
+                          else
+                            style
+                          end
+                        end
+    end
+
+    def syntax
+      syntax = @options.fetch(:syntax, :scss)
+      syntax = :indented if syntax.to_sym == :sass
+      syntax
+    end
+
+    def load_paths
+      @load_paths ||= if @options[:importer].nil?
+                        (@options[:load_paths] || []) + SassC.load_paths
+                      else
+                        []
+                      end
+    end
+
+    def post_process_source_map(source_map)
+      return unless source_map
+
+      url = URL.parse(source_map_file_url || file_url)
+      data = JSON.parse(source_map)
+      data["file"] = if validate_source_map_path?
+        URL.parse(output_url).route_from(url).to_s
+      else
+        output_url
+      end
+      data["sources"].map! do |source|
+        if source.start_with?(Protocol::FILE) && validate_source_map_path?
+          URL.parse(source).route_from(url).to_s
+        else
+          source
+        end
+      end
+
+      JSON.generate(data)
+    end
+
+    def post_process_css(css)
+      css += "\n" unless css.empty?
+      unless @source_map.nil? || omit_source_map_url?
+        url = URL.parse(output_url || file_url)
+        source_mapping_url =
+          if source_map_embed?
+            "data:application/json;base64,#{Base64.strict_encode64(@source_map)}"
+          else
+            if validate_source_map_path?
+              URL.parse(source_map_file_url).route_from(url).to_s
+            else
+              source_map_file_url
+            end
+          end
+        css += "\n/*# sourceMappingURL=#{source_mapping_url} */"
+      end
+      css
+    end
+  end
+end

data/lib/sassc/error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module SassC
+
+  class BaseError < StandardError; end
+  class NotRenderedError < BaseError; end
+  class InvalidStyleError < BaseError; end
+  class UnsupportedValue < BaseError; end
+
+  # When dealing with SyntaxErrors,
+  # it's important to provide filename and line number information.
+  # This will be used in various error reports to users, including backtraces.
+
+  class SyntaxError < BaseError
+
+    def initialize(message, filename: nil, line: nil)
+      @filename = filename
+      @line = line
+      super(message)
+    end
+
+    def backtrace
+      return nil if super.nil?
+      sass_backtrace + super
+    end
+
+    # The backtrace of the error within Sass files.
+    def sass_backtrace
+      return [] unless @filename && @line
+      ["#{@filename}:#{@line}"]
+    end
+  end
+end

data/lib/sassc/functions_handler.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SassC
+  class FunctionsHandler
+    def initialize(options)
+      @options = options
+    end
+
+    def setup(_native_options, functions: Script::Functions)
+      @callbacks = {}
+
+      functions_wrapper = Class.new do
+        attr_accessor :options
+
+        include functions
+      end.new
+      functions_wrapper.options = @options
+
+      Script.custom_functions(functions: functions).each do |custom_function|
+        callback = lambda do |native_argument_list|
+          function_arguments = arguments_from_native_list(native_argument_list)
+          begin
+            result = functions_wrapper.send(custom_function, *function_arguments)
+          rescue StandardError
+            raise ::Sass::ScriptError, "Error: error in C function #{custom_function}"
+          end
+          to_native_value(result)
+        rescue StandardError => e
+          warn "[SassC::FunctionsHandler] #{e.cause.message}"
+          raise e
+        end
+
+        @callbacks[Script.formatted_function_name(custom_function, functions: functions)] = callback
+      end
+
+      @callbacks
+    end
+
+    private
+
+    def arguments_from_native_list(native_argument_list)
+      native_argument_list.map do |native_value|
+        Script::ValueConversion.from_native(native_value, @options)
+      end.compact
+    end
+
+    def to_native_value(sass_value)
+      # if the custom function returns nil, we provide a "default" return
+      # value of an empty string
+      sass_value ||= SassC::Script::Value::String.new("")
+      sass_value.options = @options
+      Script::ValueConversion.to_native(sass_value)
+    end
+
+    def error(message)
+      $stderr.puts "[SassC::FunctionsHandler] #{message}"
+      Native.make_error(message)
+    end
+
+    begin
+      begin
+        raise RuntimeError
+      rescue StandardError
+        raise ::Sass::ScriptError
+      end
+    rescue StandardError => e
+      unless e.full_message.include?(e.cause.full_message)
+        ::Sass::ScriptError.class_eval do
+          def full_message(*args, **kwargs)
+            full_message = super(*args, **kwargs)
+            if cause
+              "#{full_message}\n#{cause.full_message(*args, **kwargs)}"
+            else
+              full_message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sassc/import_handler.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module SassC
+  class ImportHandler
+    def initialize(options)
+      @importer = if options[:importer]
+        options[:importer].new(options)
+      else
+        nil
+      end
+    end
+
+    def setup(_native_options)
+      Importer.new(@importer) if @importer
+    end
+
+    class FileImporter
+      class << self
+        def resolve_path(path, from_import)
+          ext = File.extname(path)
+          if ['.sass', '.scss', '.css'].include?(ext)
+            if from_import
+              result = exactly_one(try_path("#{without_ext(path)}.import#{ext}"))
+              return result unless result.nil?
+            end
+            return exactly_one(try_path(path))
+          end
+
+          unless ext.empty?
+            if from_import
+              result = exactly_one(try_path("#{without_ext(path)}.import#{ext}"))
+              return result unless result.nil?
+            end
+            result = exactly_one(try_path(path))
+            return result unless result.nil?
+          end
+
+          if from_import
+            result = exactly_one(try_path_with_ext("#{path}.import"))
+            return result unless result.nil?
+          end
+
+          result = exactly_one(try_path_with_ext(path))
+          return result unless result.nil?
+
+          try_path_as_dir(path, from_import)
+        end
+
+        private
+
+        def try_path_with_ext(path)
+          result = try_path("#{path}.sass") + try_path("#{path}.scss")
+          result.empty? ? try_path("#{path}.css") : result
+        end
+
+        def try_path(path)
+          partial = File.join(File.dirname(path), "_#{File.basename(path)}")
+          result = []
+          result.push(partial) if file_exist?(partial)
+          result.push(path) if file_exist?(path)
+          result
+        end
+
+        def try_path_as_dir(path, from_import)
+          return unless dir_exist? path
+
+          if from_import
+            result = exactly_one(try_path_with_ext(File.join(path, 'index.import')))
+            return result unless result.nil?
+          end
+
+          exactly_one(try_path_with_ext(File.join(path, 'index')))
+        end
+
+        def exactly_one(paths)
+          return if paths.empty?
+          return paths.first if paths.length == 1
+
+          raise "It's not clear which file to import. Found:\n#{paths.map { |path| "  #{path}" }.join("\n")}"
+        end
+
+        def file_exist?(path)
+          File.exist?(path) && File.file?(path)
+        end
+
+        def dir_exist?(path)
+          File.exist?(path) && File.directory?(path)
+        end
+
+        def without_ext(path)
+          ext = File.extname(path)
+          path.delete_suffix(ext)
+        end
+      end
+    end
+
+    private_constant :FileImporter
+
+    class Importer
+      def initialize(importer)
+        @importer = importer
+
+        @canonical_urls = {}
+        @id = 0
+        @importer_results = {}
+        @parent_urls = [URL.path_to_file_url(File.absolute_path(@importer.options[:filename] || 'stdin'))]
+      end
+
+      def canonicalize(url, from_import:)
+        if url.start_with?(Protocol::IMPORT)
+          canonical_url = @canonical_urls.delete(url.delete_prefix(Protocol::IMPORT))
+          unless @importer_results.key?(canonical_url)
+            canonical_url = resolve_file_url(canonical_url, @parent_urls.last, from_import)
+          end
+          @parent_urls.push(canonical_url)
+          canonical_url
+        elsif url.start_with?(Protocol::FILE)
+          path = URL.parse(url).route_from(@parent_urls.last).to_s
+          parent_path = URL.file_url_to_path(@parent_urls.last)
+
+          imports = @importer.imports(path, parent_path)
+          imports = [SassC::Importer::Import.new(path)] if imports.nil?
+          imports = [imports] unless imports.is_a?(Array)
+          imports.each do |import|
+            import.path = File.absolute_path(import.path, File.dirname(parent_path))
+          end
+
+          canonical_url = "#{Protocol::IMPORT}#{next_id}"
+          @importer_results[canonical_url] = imports_to_native(imports)
+          canonical_url
+        elsif url.start_with?(Protocol::LOADED)
+          canonical_url = Protocol::LOADED
+          @parent_urls.pop
+          canonical_url
+        end
+      end
+
+      def load(canonical_url)
+        if @importer_results.key?(canonical_url)
+          @importer_results.delete(canonical_url)
+        elsif canonical_url.start_with?(Protocol::FILE)
+          path = URL.file_url_to_path(canonical_url)
+          {
+            contents: File.read(path),
+            syntax: syntax(path),
+            source_map_url: canonical_url
+          }
+        elsif canonical_url.start_with?(Protocol::LOADED)
+          {
+            contents: '',
+            syntax: :scss
+          }
+        end
+      end
+
+      private
+
+      def load_paths
+        @load_paths ||= (@importer.options[:load_paths] || []) + SassC.load_paths
+      end
+
+      def resolve_file_url(url, parent_url, from_import)
+        path = URL.parse(url).route_from(parent_url).to_s
+        parent_path = URL.file_url_to_path(parent_url)
+        [File.dirname(parent_path)].concat(load_paths).each do |load_path|
+          resolved = FileImporter.resolve_path(File.absolute_path(path, load_path), from_import)
+          return URL.path_to_file_url(resolved) unless resolved.nil?
+        end
+        nil
+      end
+
+      def syntax(path)
+        case File.extname(path)
+        when '.sass'
+          :indented
+        when '.css'
+          :css
+        else
+          :scss
+        end
+      end
+
+      def imports_to_native(imports)
+        {
+          contents: imports.flat_map do |import|
+            id = next_id
+            canonical_url = URL.path_to_file_url(import.path)
+            @canonical_urls[id] = canonical_url
+            if import.source
+              @importer_results[canonical_url] = if import.source.is_a?(Hash)
+                                                   {
+                                                     contents: import.source[:contents],
+                                                     syntax: import.source[:syntax],
+                                                     source_map_url: canonical_url
+                                                   }
+                                                 else
+                                                   {
+                                                     contents: import.source,
+                                                     syntax: syntax(import.path),
+                                                     source_map_url: canonical_url
+                                                   }
+                                                 end
+            end
+            [
+              "@import \"#{Protocol::IMPORT}#{id}\";",
+              "@import \"#{Protocol::LOADED}#{id}\";"
+            ]
+          end.join("\n"),
+          syntax: :scss
+        }
+      end
+
+      def next_id
+        id = @id
+        @id = id.next
+        id.to_s
+      end
+    end
+
+    private_constant :Importer
+  end
+end