sass-embedded 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36aa31c9cb340c6a95c73c93ea480ab565a9f8f009094ec0f7f7a2239e647f2b
-  data.tar.gz: 71f325cdb5e5db87b97a931b92749c6e0ebbc91b376945fc5aa7b2fb5590928a
+  metadata.gz: 36a036051c7abed208ad60c033464cc8ebba1c7b16e0aaf4d32e7e88e7480dbe
+  data.tar.gz: d90c2b2f3c0a66c1de05cdb30fa66bb0b42b8d29ecaa84be53a36dc42fc886b2
 SHA512:
-  metadata.gz: 7f136169a9f697db2cc04c466e2268230d090db81a01e54da74880a5dde4bba1acdafe425cf8b7f35f4030a2ec4d52b56e20dbba82911be974f9c000138f1e67
-  data.tar.gz: 79507aae38d81b506a0d38ddc312bd12533bbe1d6647e0634a3755ff154c4a0a7be917d9cfbe8f7604ce2196fda9a7eb45f0f77a89c0b23513aec5b43f88abb2
+  metadata.gz: 9ea57f9e2d75135b81cc2dcdc7dd37cf1db7b185512f90b2e40a5c03d05994409d85023b61feccdc0a346443863fac2c4439c439d975adfd2404319747d1f8fc
+  data.tar.gz: 90d91290a68af79837a17dd4cd73645524e4d9e377b5e30f232df2c2a2dde1dba4f4c2a7520b66fda1e225f409804abc3b2de0df8c8998be094827982114472c

data/ext/sass/extconf.rb

@@ -1,221 +1,223 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'mkmf'
+require 'fileutils'
 require 'json'
+require 'mkmf'
 require 'open-uri'
-require 'fileutils'
-require_relative '../../lib/sass/platform'
-require_relative '../../lib/sass/compiler'
+require_relative '../../lib/sass/embedded/compiler'
+require_relative '../../lib/sass/embedded/platform'
 
 module Sass
-  # The dependency downloader. This downloads all the dependencies during gem
-  # installation. The companion Makefile then unpacks all downloaded
-  # dependencies. By default it downloads the release of each dependency
-  # from GitHub releases.
-  #
-  # It is possible to specify an alternative source or version of each
-  # dependency. Local sources can be used for offline installation.
-  #
-  # @example
-  #   gem install sass-embedded -- \
-  #     --with-protoc=file:///path/to/protoc-*.zip \
-  #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
-  #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto
-  # @example
-  #   bundle config build.sass-embedded \
-  #     --with-protoc=file:///path/to/protoc-*.zip \
-  #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
-  #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto
-  class Extconf
-    def initialize
-      fetch_with_config('protoc', false) { default_protoc }
-      fetch_with_config('sass-embedded', false) { default_sass_embedded }
-      fetch_with_config('sass-embedded-protocol', false) { default_sass_embedded_protocol }
-    end
+  class Embedded
+    # The dependency downloader. This downloads all the dependencies during gem
+    # installation. The companion Makefile then unpacks all downloaded
+    # dependencies. By default it downloads the release of each dependency
+    # from GitHub releases.
+    #
+    # It is possible to specify an alternative source or version of each
+    # dependency. Local sources can be used for offline installation.
+    #
+    # @example
+    #   gem install sass-embedded -- \
+    #     --with-protoc=file:///path/to/protoc-*.zip \
+    #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
+    #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto
+    # @example
+    #   bundle config build.sass-embedded \
+    #     --with-protoc=file:///path/to/protoc-*.zip \
+    #     --with-sass-embedded=file:///path/to/sass_embedded-*.(tar.gz|zip) \
+    #     --with-sass-embedded-protocol=file:///path/to/embedded_sass.proto
+    class Extconf
+      def initialize
+        fetch_with_config('protoc', false) { default_protoc }
+        fetch_with_config('sass-embedded', false) { default_sass_embedded }
+        fetch_with_config('sass-embedded-protocol', false) { default_sass_embedded_protocol }
+      end
 
-    private
+      private
 
-    def fetch_with_config(config, default)
-      val = with_config(config, default)
-      case val
-      when true
-        if block_given?
-          fetch yield
+      def fetch_with_config(config, default)
+        val = with_config(config, default)
+        case val
+        when true
+          if block_given?
+            fetch yield
+          else
+            fetch default
+          end
+        when false
+          nil
         else
-          fetch default
+          fetch val
         end
-      when false
-        nil
-      else
-        fetch val
       end
-    end
 
-    def fetch(uri_s)
-      uri = URI.parse(uri_s)
-      path = File.absolute_path(File.basename(uri.path), __dir__)
-      if uri.is_a?(URI::File) || uri.instance_of?(URI::Generic)
-        FileUtils.copy_file uri.path, path
-      elsif uri.respond_to? :open
-        puts "curl -fsSLo #{path} -- #{uri}"
-        uri.open do |source|
-          File.open(path, 'wb') do |destination|
-            destination.write source.read
+      def fetch(uri_s)
+        uri = URI.parse(uri_s)
+        path = File.absolute_path(File.basename(uri.path), __dir__)
+        if uri.is_a?(URI::File) || uri.instance_of?(URI::Generic)
+          FileUtils.copy_file uri.path, path
+        elsif uri.respond_to? :open
+          puts "curl -fsSLo #{path} -- #{uri}"
+          uri.open do |source|
+            File.open(path, 'wb') do |destination|
+              destination.write source.read
+            end
           end
+        else
+          raise
         end
-      else
+      rescue StandardError
+        warn "ERROR:  Error fetching #{uri_s}:"
         raise
       end
-    rescue StandardError
-      warn "ERROR:  Error fetching #{uri_s}:"
-      raise
-    end
 
-    def resolve_tag_name(repo, *requirements, gh_release: true)
-      requirements = Gem::Requirement.create(*requirements)
+      def resolve_tag_name(repo, *requirements, gh_release: true)
+        requirements = Gem::Requirement.create(*requirements)
 
-      satisfied = lambda { |version|
-        Gem::Version.correct?(version) && requirements.satisfied_by?(Gem::Version.new(version))
-      }
+        satisfied = lambda { |version|
+          Gem::Version.correct?(version) && requirements.satisfied_by?(Gem::Version.new(version))
+        }
 
-      headers = {}
-      headers['Authorization'] = "token #{ENV['GITHUB_TOKEN']}" if ENV['GITHUB_TOKEN']
+        headers = {}
+        headers['Authorization'] = "token #{ENV['GITHUB_TOKEN']}" if ENV['GITHUB_TOKEN']
 
-      begin
-        if gh_release
-          releases_uri = "https://github.com/#{repo}/releases"
-          uri = "#{releases_uri}/latest"
-          tag_name = URI.parse(uri).open do |file|
-            return nil if file.base_uri == releases_uri
+        begin
+          if gh_release
+            releases_uri = "https://github.com/#{repo}/releases"
+            uri = "#{releases_uri}/latest"
+            tag_name = URI.parse(uri).open do |file|
+              return nil if file.base_uri == releases_uri
 
-            latest = File.basename file.base_uri.to_s
-            latest if satisfied.call latest
-          end
+              latest = File.basename file.base_uri.to_s
+              latest if satisfied.call latest
+            end
 
-          return tag_name unless tag_name.nil?
+            return tag_name unless tag_name.nil?
 
-          uri = "https://api.github.com/repos/#{repo}/releases?per_page=100"
-          tag_name = URI.parse(uri).open(headers) do |file|
-            JSON.parse(file.read).map { |release| release['tag_name'] }
-          end
-                        .find(satisfied)&.peek
-        else
-          uri = "https://api.github.com/repos/#{repo}/tags?per_page=100"
-          tag_name = URI.parse(uri).open(headers) do |file|
-            JSON.parse(file.read).map { |tag| tag['name'] }
+            uri = "https://api.github.com/repos/#{repo}/releases?per_page=100"
+            tag_name = URI.parse(uri).open(headers) do |file|
+              JSON.parse(file.read).map { |release| release['tag_name'] }
+            end
+                          .find(satisfied)&.peek
+          else
+            uri = "https://api.github.com/repos/#{repo}/tags?per_page=100"
+            tag_name = URI.parse(uri).open(headers) do |file|
+              JSON.parse(file.read).map { |tag| tag['name'] }
+            end
+                          .find(satisfied)&.peek
           end
-                        .find(satisfied)&.peek
+
+          return tag_name unless tag_name.nil?
+        rescue OpenURI::HTTPError => e
+          warn "WARNING:  Error fetching #{uri}: #{e}"
         end
 
-        return tag_name unless tag_name.nil?
-      rescue OpenURI::HTTPError => e
-        warn "WARNING:  Error fetching #{uri}: #{e}"
+        requirements.requirements
+                    .map { |requirement| requirement.last.to_s.gsub('.pre.', '-') }
+                    .find(satisfied)&.peek
       end
 
-      requirements.requirements
-                  .map { |requirement| requirement.last.to_s.gsub('.pre.', '-') }
-                  .find(satisfied)&.peek
-    end
+      def default_sass_embedded
+        repo = 'sass/dart-sass-embedded'
+
+        tag_name = resolve_tag_name(repo, Compiler::REQUIREMENTS)
 
-    def default_sass_embedded
-      repo = 'sass/dart-sass-embedded'
-
-      tag_name = resolve_tag_name(repo, Compiler::REQUIREMENTS)
-
-      os = case Platform::OS
-           when 'darwin'
-             'macos'
-           when 'linux'
-             'linux'
-           when 'windows'
-             'windows'
-           else
-             raise "Unsupported OS: #{Platform::OS}"
-           end
-
-      arch = case Platform::ARCH
-             when 'x86_64'
-               'x64'
-             when 'i386'
-               'ia32'
-             when 'aarch64'
-               raise "Unsupported Arch: #{Platform::ARCH}" unless Platform::OS == 'darwin'
-
-               'x64'
+        os = case Platform::OS
+             when 'darwin'
+               'macos'
+             when 'linux'
+               'linux'
+             when 'windows'
+               'windows'
              else
-               raise "Unsupported Arch: #{Platform::ARCH}"
+               raise "Unsupported OS: #{Platform::OS}"
              end
 
-      ext = case os
-            when 'windows'
-              'zip'
-            else
-              'tar.gz'
-            end
+        arch = case Platform::ARCH
+               when 'x86_64'
+                 'x64'
+               when 'i386'
+                 'ia32'
+               when 'aarch64'
+                 raise "Unsupported Arch: #{Platform::ARCH}" unless Platform::OS == 'darwin'
 
-      "https://github.com/#{repo}/releases/download/#{tag_name}/sass_embedded-#{tag_name}-#{os}-#{arch}.#{ext}"
-    end
+                 'x64'
+               else
+                 raise "Unsupported Arch: #{Platform::ARCH}"
+               end
 
-    def default_protoc
-      repo = 'protocolbuffers/protobuf'
+        ext = case os
+              when 'windows'
+                'zip'
+              else
+                'tar.gz'
+              end
 
-      spec = Gem::Dependency.new('google-protobuf').to_spec
+        "https://github.com/#{repo}/releases/download/#{tag_name}/sass_embedded-#{tag_name}-#{os}-#{arch}.#{ext}"
+      end
 
-      tag_name = "v#{spec.version}"
+      def default_protoc
+        repo = 'protocolbuffers/protobuf'
 
-      os = case Platform::OS
-           when 'darwin'
-             'osx'
-           when 'linux'
-             'linux'
-           when 'windows'
-             'win'
-           else
-             raise "Unsupported OS: #{Platform::OS}"
-           end
+        spec = Gem::Dependency.new('google-protobuf').to_spec
 
-      arch = case Platform::ARCH
-             when 'aarch64'
-               if Platform::OS == 'darwin'
+        tag_name = "v#{spec.version}"
+
+        os = case Platform::OS
+             when 'darwin'
+               'osx'
+             when 'linux'
+               'linux'
+             when 'windows'
+               'win'
+             else
+               raise "Unsupported OS: #{Platform::OS}"
+             end
+
+        arch = case Platform::ARCH
+               when 'aarch64'
+                 if Platform::OS == 'darwin'
+                   'x86_64'
+                 else
+                   'aarch_64'
+                 end
+               when 'sparcv9'
+                 's390'
+               when 'i386'
+                 'x86_32'
+               when 'x86_64'
                  'x86_64'
+               when 'powerpc64'
+                 'ppcle_64'
                else
-                 'aarch_64'
+                 raise "Unsupported Arch: #{Platform::ARCH}"
                end
-             when 'sparcv9'
-               's390'
-             when 'i386'
-               'x86_32'
-             when 'x86_64'
-               'x86_64'
-             when 'powerpc64'
-               'ppcle_64'
-             else
-               raise "Unsupported Arch: #{Platform::ARCH}"
-             end
 
-      os_arch = case os
-                when 'win'
-                  os + arch.split('_').last
-                else
-                  "#{os}-#{arch}"
-                end
+        os_arch = case os
+                  when 'win'
+                    os + arch.split('_').last
+                  else
+                    "#{os}-#{arch}"
+                  end
 
-      ext = 'zip'
+        ext = 'zip'
 
-      "https://github.com/#{repo}/releases/download/#{tag_name}/protoc-#{tag_name[1..]}-#{os_arch}.#{ext}"
-    end
+        "https://github.com/#{repo}/releases/download/#{tag_name}/protoc-#{tag_name[1..]}-#{os_arch}.#{ext}"
+      end
 
-    def default_sass_embedded_protocol
-      repo = 'sass/embedded-protocol'
+      def default_sass_embedded_protocol
+        repo = 'sass/embedded-protocol'
 
-      tag_name = IO.popen([Compiler::DART_SASS_EMBEDDED, '--version']) do |file|
-        JSON.parse(file.read)['protocolVersion']
-      end
+        tag_name = IO.popen([Compiler::DART_SASS_EMBEDDED, '--version']) do |file|
+          JSON.parse(file.read)['protocolVersion']
+        end
 
-      "https://raw.githubusercontent.com/#{repo}/#{tag_name}/embedded_sass.proto"
+        "https://raw.githubusercontent.com/#{repo}/#{tag_name}/embedded_sass.proto"
+      end
     end
   end
 end
 
-Sass::Extconf.new
+Sass::Embedded::Extconf.new

data/lib/sass/embedded/compile.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require_relative 'observer'
+require_relative 'protocol'
+require_relative 'util'
+
+module Sass
+  class Embedded
+    # The {Observer} for {Embedded#render}.
+    class CompileContext
+      include Observer
+
+      def initialize(transport, id,
+                     data:,
+                     file:,
+                     indented_syntax:,
+                     include_paths:,
+                     output_style:,
+                     source_map:,
+                     out_file:,
+                     functions:,
+                     importer:)
+        raise ArgumentError, 'either data or file must be set' if file.nil? && data.nil?
+
+        @id = id
+        @data = data
+        @file = file
+        @indented_syntax = indented_syntax
+        @include_paths = include_paths
+        @output_style = output_style
+        @source_map = source_map
+        @out_file = out_file
+        @global_functions = functions.keys
+        @functions = functions.transform_keys do |key|
+          key.to_s.split('(')[0].chomp
+        end
+        @importer = importer
+        @import_responses = {}
+
+        super(transport)
+
+        send_message compile_request
+      end
+
+      def update(error, message)
+        raise error unless error.nil?
+
+        case message
+        when EmbeddedProtocol::OutboundMessage::CompileResponse
+          return unless message.id == @id
+
+          Thread.new do
+            super(nil, message)
+          end
+        when EmbeddedProtocol::OutboundMessage::LogEvent
+          return unless message.compilation_id == @id && $stderr.tty?
+
+          warn message.formatted
+        when EmbeddedProtocol::OutboundMessage::CanonicalizeRequest
+          return unless message.compilation_id == @id
+
+          Thread.new do
+            send_message canonicalize_response message
+          end
+        when EmbeddedProtocol::OutboundMessage::ImportRequest
+          return unless message.compilation_id == @id
+
+          Thread.new do
+            send_message import_response message
+          end
+        when EmbeddedProtocol::OutboundMessage::FileImportRequest
+          raise NotImplementedError, 'FileImportRequest is not implemented'
+        when EmbeddedProtocol::OutboundMessage::FunctionCallRequest
+          return unless message.compilation_id == @id
+
+          Thread.new do
+            send_message function_call_response message
+          end
+        end
+      rescue StandardError => e
+        Thread.new do
+          super(e, nil)
+        end
+      end
+
+      private
+
+      def compile_request
+        EmbeddedProtocol::InboundMessage::CompileRequest.new(
+          id: @id,
+          string: string,
+          path: path,
+          style: style,
+          source_map: source_map,
+          importers: importers,
+          global_functions: global_functions,
+          alert_color: $stderr.tty?,
+          alert_ascii: Platform::OS == 'windows'
+        )
+      end
+
+      def canonicalize_response(canonicalize_request)
+        url = Util.file_uri_from_path(File.absolute_path(canonicalize_request.url, (@file.nil? ? 'stdin' : @file)))
+
+        begin
+          result = @importer[canonicalize_request.importer_id].call canonicalize_request.url, @file
+          raise result if result.is_a? StandardError
+        rescue StandardError => e
+          return EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id,
+            error: e.message
+          )
+        end
+
+        if result&.key? :contents
+          @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: canonicalize_request.id,
+            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+              contents: result[:contents],
+              syntax: EmbeddedProtocol::Syntax::SCSS,
+              source_map_url: nil
+            )
+          )
+          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id,
+            url: url
+          )
+        elsif result&.key? :file
+          canonicalized_url = Util.file_uri_from_path(File.absolute_path(result[:file]))
+
+          # TODO: FileImportRequest is not supported yet.
+          # Workaround by reading contents and return it when server asks
+          @import_responses[canonicalized_url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: canonicalize_request.id,
+            success: EmbeddedProtocol::InboundMessage::ImportResponse::ImportSuccess.new(
+              contents: File.read(result[:file]),
+              syntax: EmbeddedProtocol::Syntax::SCSS,
+              source_map_url: nil
+            )
+          )
+
+          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id,
+            url: canonicalized_url
+          )
+        else
+          EmbeddedProtocol::InboundMessage::CanonicalizeResponse.new(
+            id: canonicalize_request.id
+          )
+        end
+      end
+
+      def import_response(import_request)
+        url = import_request.url
+
+        if @import_responses.key? url
+          @import_responses[url].id = import_request.id
+        else
+          @import_responses[url] = EmbeddedProtocol::InboundMessage::ImportResponse.new(
+            id: import_request.id,
+            error: "Failed to import: #{url}"
+          )
+        end
+
+        @import_responses[url]
+      end
+
+      def function_call_response(function_call_request)
+        # TODO: convert argument_list to **kwargs
+        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+          id: function_call_request.id,
+          success: @functions[function_call_request.name].call(*function_call_request.arguments),
+          accessed_argument_lists: function_call_request.arguments
+            .filter { |argument| argument.value == :argument_list }
+            .map { |argument| argument.argument_list.id }
+        )
+      rescue StandardError => e
+        EmbeddedProtocol::InboundMessage::FunctionCallResponse.new(
+          id: function_call_request.id,
+          error: e.message
+        )
+      end
+
+      def syntax
+        if @indented_syntax == true
+          EmbeddedProtocol::Syntax::INDENTED
+        else
+          EmbeddedProtocol::Syntax::SCSS
+        end
+      end
+
+      def url
+        return if @file.nil?
+
+        Util.file_uri_from_path File.absolute_path @file
+      end
+
+      def string
+        return if @data.nil?
+
+        EmbeddedProtocol::InboundMessage::CompileRequest::StringInput.new(
+          source: @data,
+          url: url,
+          syntax: syntax
+        )
+      end
+
+      def path
+        @file if @data.nil?
+      end
+
+      def style
+        case @output_style&.to_sym
+        when :expanded
+          EmbeddedProtocol::OutputStyle::EXPANDED
+        when :compressed
+          EmbeddedProtocol::OutputStyle::COMPRESSED
+        else
+          raise ArgumentError, 'output_style must be one of :expanded, :compressed'
+        end
+      end
+
+      def source_map
+        @source_map.is_a?(String) || (@source_map == true && !@out_file.nil?)
+      end
+
+      attr_reader :global_functions
+
+      # Order
+      # 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.
+      def importers
+        custom_importers = @importer.map.with_index do |_, id|
+          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+            importer_id: id
+          )
+        end
+
+        include_path_importers = @include_paths
+                                 .concat(Embedded.include_paths)
+                                 .map do |include_path|
+          EmbeddedProtocol::InboundMessage::CompileRequest::Importer.new(
+            path: File.absolute_path(include_path)
+          )
+        end
+
+        custom_importers.concat include_path_importers
+      end
+    end
+  end
+end

data/lib/sass/embedded/compiler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'platform'
+
+module Sass
+  class Embedded
+    module Compiler
+      DART_SASS_EMBEDDED = File.absolute_path(
+        "../../../ext/sass/sass_embedded/dart-sass-embedded#{Platform::OS == 'windows' ? '.bat' : ''}", __dir__
+      )
+
+      PROTOCOL_ERROR_ID = 4_294_967_295
+
+      REQUIREMENTS = '~> 1.0.0-beta.11'
+    end
+  end
+end