sassc-embedded 1.64.2 → 1.68.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0c3f79381ebf1f13b2b1a3e049acc02fe092da0fd229a87095014e93347c317
-  data.tar.gz: c99f48ee690cc56999888b6f92013a18ef6f6df3f2cc7baa9fd2080393078026
+  metadata.gz: 0c1bae171b142e9c93398da7fd657e968c0804ce760bd7c05e04dc59a1d6c408
+  data.tar.gz: e45f9276e88a116aa2f83f592187b3705a6b2989b7837e90ca6917fbc418a51e
 SHA512:
-  metadata.gz: 2065c04a11cc220990695434439602abb7b99710463b3da0541a25a2ef451a31e64ccce15852edd4e6a0e74c9c8ae3cd2cee0fc862e51e1ed20817ddc374095a
-  data.tar.gz: e1c3107e97173a4018676c10244cee380099d0d615283e838b2191460d0c310ee83ab15316c9525c011bf55c778bc1c58678ce6fb11babecede27de818fbb761
+  metadata.gz: 5f36c1fd78fbebbb9af4bf20126b0024aa0ca15a1900ed258390c449d1de36294c96160c0e9c76777d1a2ff053564b650b0b048038ceb03f7a2c64f3c9f8d88f
+  data.tar.gz: fc2bf82ab1c39773ea130bea388028c649dab02e71e35c9f31a2cbbb4f9a30be4718a535b628f5dbeef5fac1b43009e6c3776765c3d10b2399d0aba8019bd9ab

data/README.md

@@ -14,12 +14,51 @@ It has been tested with:
 - [`sprockets`](https://github.com/rails/sprockets)
 - [`sprockets-rails`](https://github.com/rails/sprockets-rails)
 
-## Install
+## Uninstall `sassc`
 
-Add these lines to your application's Gemfile:
+Execute:
+
+``` sh
+bundle remove sassc
+```
+
+Or uninstall it yourself as:
+
+``` sh
+gem uninstall sassc
+```
+
+**If your application has a transitive dependency on `sassc` that cannot be removed, you can use any of the following workarounds.**
+
+### Workaround One
+
+Add this line to your application's Gemfile:
 
 ``` ruby
 gem 'sassc', github: 'sass/sassc-ruby', ref: 'refs/pull/233/head'
+```
+
+And then execute:
+
+``` sh
+bundle
+```
+
+The fork of `sassc` at https://github.com/sass/sassc-ruby/pull/233 will load the shim automatically when `require 'sassc'` is invoked, meaning no other code changes needed in your application.
+
+### Workaround Two
+
+Add this line to your application's code:
+
+``` ruby
+require 'sassc-embedded'
+```
+
+## Install `sassc-embedded`
+
+Add this line to your application's Gemfile:
+
+``` ruby
 gem 'sassc-embedded'
 ```
 
@@ -35,12 +74,6 @@ Or install it yourself as:
 gem install sassc-embedded
 ```
 
----
-
-The fork of `sassc` at https://github.com/sass/sassc-ruby/pull/233 removes the libsass extension and loads the shim when `require 'sassc'` is invoked.
-
-Alternatively, the original `sassc` gem can be used, but you must explictly call `require 'sassc-embedded'` to load the shim.
-
 ## Usage
 
 This shim utilizes `sass-embedded` to allow you to compile SCSS or SASS syntax to CSS. To compile, use a `SassC::Engine`, e.g.:

data/lib/sassc/embedded/version.rb

@@ -2,6 +2,6 @@
 
 module SassC
   module Embedded
-    VERSION = '1.64.2'
+    VERSION = '1.68.1'
   end
 end

data/lib/sassc/embedded.rb

@@ -49,7 +49,7 @@ module SassC
         source_mapping_url = if source_map_embed?
                                "data:application/json;base64,#{[@source_map].pack('m0')}"
                              else
-                               URL.parse(source_map_file_url).route_from(url).to_s
+                               URL.unescape(URL.parse(source_map_file_url).route_from(url).to_s)
                              end
         css += "\n/*# sourceMappingURL=#{source_mapping_url} */"
       end
@@ -60,7 +60,9 @@ module SassC
       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))
+      path = if url&.start_with?(Protocol::FILE)
+               URL.unescape(URL.parse(url).route_from(URL.path_to_file_url("#{Dir.pwd}/")).to_s)
+             end
       raise SyntaxError.new(e.full_message, filename: path, line: line)
     end
 
@@ -77,10 +79,10 @@ module SassC
 
       url = URL.parse(source_map_file_url || file_url)
       data = JSON.parse(@source_map)
-      data['file'] = URL.parse(output_url).route_from(url).to_s if output_url
+      data['file'] = URL.unescape(URL.parse(output_url).route_from(url).to_s) if output_url
       data['sources'].map! do |source|
         if source.start_with?(Protocol::FILE)
-          URL.parse(source).route_from(url).to_s
+          URL.unescape(URL.parse(source).route_from(url).to_s)
         else
           source
         end
@@ -298,16 +300,16 @@ module SassC
         @parent_urls = [URL.path_to_file_url(File.absolute_path(@importer.options[:filename] || 'stdin'))]
       end
 
-      def canonicalize(url, from_import:)
+      def canonicalize(url, context)
         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)
+            canonical_url = resolve_file_url(canonical_url, @parent_urls.last, context.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
+          path = URL.unescape(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)
@@ -318,7 +320,7 @@ module SassC
           end
 
           canonical_url = "#{Protocol::IMPORT}#{next_id}"
-          @importer_results[canonical_url] = imports_to_native(imports, from_import)
+          @importer_results[canonical_url] = imports_to_native(imports, context.from_import)
           canonical_url
         elsif url.start_with?(Protocol::LOADED)
           canonical_url = Protocol::LOADED
@@ -352,7 +354,7 @@ module SassC
       end
 
       def resolve_file_url(url, parent_url, from_import)
-        path = URL.parse(url).route_from(parent_url).to_s
+        path = URL.unescape(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)

data/vendor/github.com/sass/sassc-ruby/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) Ryan Boland & Contributors
+
+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/vendor/github.com/sass/sassc-ruby/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/vendor/github.com/sass/sassc-ruby/lib/sassc/engine.rb

@@ -0,0 +1,141 @@
+# 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?
+
+      data_context = Native.make_data_context(@template)
+      context = Native.data_context_get_context(data_context)
+      native_options = Native.context_get_options(context)
+
+      Native.option_set_is_indented_syntax_src(native_options, true) if sass?
+      Native.option_set_input_path(native_options, filename) if filename
+      Native.option_set_precision(native_options, precision) if precision
+      Native.option_set_include_path(native_options, load_paths)
+      Native.option_set_output_style(native_options, output_style_enum)
+      Native.option_set_source_comments(native_options, true) if line_comments?
+      Native.option_set_source_map_file(native_options, source_map_file) if source_map_file
+      Native.option_set_source_map_embed(native_options, true) if source_map_embed?
+      Native.option_set_source_map_contents(native_options, true) if source_map_contents?
+      Native.option_set_omit_source_map_url(native_options, true) if omit_source_map_url?
+
+      import_handler.setup(native_options)
+      functions_handler.setup(native_options, functions: @functions)
+
+      status = Native.compile_data_context(data_context)
+
+      if status != 0
+        message = Native.context_get_error_message(context)
+        filename = Native.context_get_error_file(context)
+        line = Native.context_get_error_line(context)
+
+        raise SyntaxError.new(message, filename: filename, line: line)
+      end
+
+      css = Native.context_get_output_string(context)
+
+      @dependencies = Native.context_get_included_files(context)
+      @source_map   = Native.context_get_source_map_string(context)
+
+      css.force_encoding(@template.encoding)
+      @source_map.force_encoding(@template.encoding) if @source_map.is_a?(String)
+
+      return css unless quiet?
+    ensure
+      Native.delete_data_context(data_context) if data_context
+    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 import_handler
+      @import_handler ||= ImportHandler.new(@options)
+    end
+
+    def functions_handler
+      @functions_handler = FunctionsHandler.new(@options)
+    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_")
+        style = style.to_sym
+        raise InvalidStyleError unless Native::SassOutputStyle.symbols.include?(style)
+        style
+      end
+    end
+
+    def load_paths
+      paths = (@options[:load_paths] || []) + SassC.load_paths
+      paths.join(File::PATH_SEPARATOR) unless paths.empty?
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/error.rb

@@ -0,0 +1,37 @@
+# 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/vendor/github.com/sass/sassc-ruby/lib/sassc/functions_handler.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SassC
+  class FunctionsHandler
+    def initialize(options)
+      @options = options
+    end
+
+    def setup(native_options, functions: Script::Functions)
+      @callbacks = {}
+      @function_names = {}
+
+      list = Native.make_function_list(Script.custom_functions(functions: functions).count)
+
+      # use an anonymous class wrapper to avoid mutations in a threaded environment
+      functions_wrapper = Class.new do
+        attr_accessor :options
+        include functions
+      end.new
+      functions_wrapper.options = @options
+
+      Script.custom_functions(functions: functions).each_with_index do |custom_function, i|
+        @callbacks[custom_function] = FFI::Function.new(:pointer, [:pointer, :pointer]) do |native_argument_list, cookie|
+          begin
+            function_arguments = arguments_from_native_list(native_argument_list)
+            result = functions_wrapper.send(custom_function, *function_arguments)
+            to_native_value(result)
+          rescue StandardError => exception
+            # This rescues any exceptions that occur either in value conversion
+            # or during the execution of a custom function.
+            error(exception.message)
+          end
+        end
+
+        @function_names[custom_function] = Script.formatted_function_name(custom_function, functions: functions)
+
+        callback = Native.make_function(
+          @function_names[custom_function],
+          @callbacks[custom_function],
+          nil
+        )
+
+        Native::function_set_list_entry(list, i, callback)
+      end
+
+      Native::option_set_c_functions(native_options, list)
+    end
+
+    private
+
+    def arguments_from_native_list(native_argument_list)
+      native_argument_list_length = Native.list_get_length(native_argument_list)
+
+      (0...native_argument_list_length).map do |i|
+        native_value = Native.list_get_value(native_argument_list, i)
+        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
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/import_handler.rb

@@ -0,0 +1,50 @@
+# 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)
+      return unless @importer
+
+      importer_callback = Native.make_importer(import_function, nil)
+
+      list = Native.make_function_list(1)
+      Native::function_set_list_entry(list, 0, importer_callback)
+
+      Native.option_set_c_importers(native_options, list)
+    end
+
+    private
+
+    def import_function
+      @import_function ||= FFI::Function.new(:pointer, [:string, :pointer, :pointer]) do |path, importer_entry, compiler|
+        last_import = Native::compiler_get_last_import(compiler)
+        parent_path = Native::import_get_abs_path(last_import)
+
+        imports = [*@importer.imports(path, parent_path)]
+        imports_to_native(imports)
+      end
+    end
+
+    def imports_to_native(imports)
+      import_list = Native.make_import_list(imports.size)
+
+      imports.each_with_index do |import, i|
+        source = import.source ? Native.native_string(import.source) : nil
+        source_map_path = nil
+
+        entry = Native.make_import_entry(import.path, source, source_map_path)
+        Native.import_set_list_entry(import_list, i, entry)
+      end
+
+      import_list
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/importer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SassC
+  class Importer
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def imports(path, parent_path)
+      # A custom importer must override this method.
+      # Custom importer may return an Import, or an array of Imports.
+      raise NotImplementedError
+    end
+
+    class Import
+      attr_accessor :path, :source, :source_map_path
+
+      def initialize(path, source: nil, source_map_path: nil)
+        @path = path
+        @source = source
+        @source_map_path = source_map_path
+      end
+
+      def to_s
+        "Import: #{path} #{source} #{source_map_path}"
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/native/native_context_api.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    attach_function :version, :libsass_version, [], :string
+
+    # Create and initialize an option struct
+    # ADDAPI struct Sass_Options* ADDCALL sass_make_options (void);
+    attach_function :sass_make_options, [], :sass_options_ptr
+
+    # Create and initialize a specific context
+    # ADDAPI struct Sass_File_Context* ADDCALL sass_make_file_context (const char* input_path);
+    # ADDAPI struct Sass_Data_Context* ADDCALL sass_make_data_context (char* source_string);
+    attach_function :sass_make_file_context, [:string], :sass_file_context_ptr
+    attach_function :_make_data_context, :sass_make_data_context, [:pointer], :sass_data_context_ptr
+
+    def self.make_data_context(data)
+      _make_data_context(Native.native_string(data))
+    end
+
+    # Call the compilation step for the specific context
+    # ADDAPI int ADDCALL sass_compile_file_context (struct Sass_File_Context* ctx);
+    # ADDAPI int ADDCALL sass_compile_data_context (struct Sass_Data_Context* ctx);
+    attach_function :sass_compile_file_context, [:sass_file_context_ptr], :int
+    attach_function :sass_compile_data_context, [:sass_data_context_ptr], :int
+
+    # Create a sass compiler instance for more control
+    # ADDAPI struct Sass_Compiler* ADDCALL sass_make_file_compiler (struct Sass_File_Context* file_ctx);
+    # ADDAPI struct Sass_Compiler* ADDCALL sass_make_data_compiler (struct Sass_Data_Context* data_ctx);
+
+    # Execute the different compilation steps individually
+    # Usefull if you only want to query the included files
+    # ADDAPI int ADDCALL sass_compiler_parse(struct Sass_Compiler* compiler);
+    # ADDAPI int ADDCALL sass_compiler_execute(struct Sass_Compiler* compiler);
+
+    # Release all memory allocated with the compiler
+    # This does _not_ include any contexts or options
+    # ADDAPI void ADDCALL sass_delete_compiler(struct Sass_Compiler* compiler);
+
+    # Release all memory allocated and also ourself
+    # ADDAPI void ADDCALL sass_delete_file_context (struct Sass_File_Context* ctx);
+    # ADDAPI void ADDCALL sass_delete_data_context (struct Sass_Data_Context* ctx);
+    attach_function :sass_delete_file_context, [:sass_file_context_ptr], :void
+    attach_function :sass_delete_data_context, [:sass_data_context_ptr], :void
+
+    # Getters for context from specific implementation
+    # ADDAPI struct Sass_Context* ADDCALL sass_file_context_get_context (struct Sass_File_Context* file_ctx);
+    # ADDAPI struct Sass_Context* ADDCALL sass_data_context_get_context (struct Sass_Data_Context* data_ctx);
+    attach_function :sass_file_context_get_context, [:sass_file_context_ptr], :sass_context_ptr
+    attach_function :sass_data_context_get_context, [:sass_data_context_ptr], :sass_context_ptr
+
+    # Getters for context options from Sass_Context
+    # ADDAPI struct Sass_Options* ADDCALL sass_context_get_options (struct Sass_Context* ctx);
+    # ADDAPI struct Sass_Options* ADDCALL sass_file_context_get_options (struct Sass_File_Context* file_ctx);
+    # ADDAPI struct Sass_Options* ADDCALL sass_data_context_get_options (struct Sass_Data_Context* data_ctx);
+    # ADDAPI void ADDCALL sass_file_context_set_options (struct Sass_File_Context* file_ctx, struct Sass_Options* opt);
+    # ADDAPI void ADDCALL sass_data_context_set_options (struct Sass_Data_Context* data_ctx, struct Sass_Options* opt);
+    attach_function :sass_context_get_options, [:sass_context_ptr], :sass_options_ptr
+    attach_function :sass_file_context_get_options, [:sass_file_context_ptr], :sass_options_ptr
+    attach_function :sass_data_context_get_options, [:sass_data_context_ptr], :sass_options_ptr
+    attach_function :sass_file_context_set_options, [:sass_file_context_ptr, :sass_options_ptr], :void
+    attach_function :sass_data_context_set_options, [:sass_data_context_ptr, :sass_options_ptr], :void
+
+    # Getters for options
+    # ADDAPI int ADDCALL sass_option_get_precision (struct Sass_Options* options);
+    # ADDAPI enum Sass_Output_Style ADDCALL sass_option_get_output_style (struct Sass_Options* options);
+    # ADDAPI bool ADDCALL sass_option_get_source_comments (struct Sass_Options* options);
+    # ADDAPI bool ADDCALL sass_option_get_source_map_embed (struct Sass_Options* options);
+    # ADDAPI bool ADDCALL sass_option_get_source_map_contents (struct Sass_Options* options);
+    # ADDAPI bool ADDCALL sass_option_get_omit_source_map_url (struct Sass_Options* options);
+    # ADDAPI bool ADDCALL sass_option_get_is_indented_syntax_src (struct Sass_Options* options);
+    # ADDAPI const char* ADDCALL sass_option_get_input_path (struct Sass_Options* options);
+    # ADDAPI const char* ADDCALL sass_option_get_output_path (struct Sass_Options* options);
+    # ADDAPI const char* ADDCALL sass_option_get_include_path (struct Sass_Options* options);
+    # ADDAPI const char* ADDCALL sass_option_get_source_map_file (struct Sass_Options* options);
+    # ADDAPI Sass_C_Function_List ADDCALL sass_option_get_c_functions (struct Sass_Options* options);
+    attach_function :sass_option_get_precision, [:sass_options_ptr], :int
+    attach_function :sass_option_get_output_style, [:sass_options_ptr], SassOutputStyle
+    attach_function :sass_option_get_source_comments, [:sass_options_ptr], :bool
+    attach_function :sass_option_get_source_map_embed, [:sass_options_ptr], :bool
+    attach_function :sass_option_get_source_map_contents, [:sass_options_ptr], :bool
+    attach_function :sass_option_get_omit_source_map_url, [:sass_options_ptr], :bool
+    attach_function :sass_option_get_is_indented_syntax_src, [:sass_options_ptr], :bool
+    attach_function :sass_option_get_input_path, [:sass_options_ptr], :string
+    attach_function :sass_option_get_output_path, [:sass_options_ptr], :string
+    attach_function :sass_option_get_include_path, [:sass_options_ptr], :string
+    attach_function :sass_option_get_source_map_file, [:sass_options_ptr], :string
+    attach_function :sass_option_get_c_functions, [:sass_options_ptr], :sass_c_function_list_ptr
+    # ADDAPI Sass_C_Import_Callback ADDCALL sass_option_get_importer (struct Sass_Options* options);
+
+    # Setters for options
+    # ADDAPI void ADDCALL sass_option_set_precision (struct Sass_Options* options, int precision);
+    # ADDAPI void ADDCALL sass_option_set_output_style (struct Sass_Options* options, enum Sass_Output_Style output_style);
+    # ADDAPI void ADDCALL sass_option_set_source_comments (struct Sass_Options* options, bool source_comments);
+    # ADDAPI void ADDCALL sass_option_set_source_map_embed (struct Sass_Options* options, bool source_map_embed);
+    # ADDAPI void ADDCALL sass_option_set_source_map_contents (struct Sass_Options* options, bool source_map_contents);
+    # ADDAPI void ADDCALL sass_option_set_omit_source_map_url (struct Sass_Options* options, bool omit_source_map_url);
+    # ADDAPI void ADDCALL sass_option_set_is_indented_syntax_src (struct Sass_Options* options, bool is_indented_syntax_src);
+    # ADDAPI void ADDCALL sass_option_set_input_path (struct Sass_Options* options, const char* input_path);
+    # ADDAPI void ADDCALL sass_option_set_output_path (struct Sass_Options* options, const char* output_path);
+    # ADDAPI void ADDCALL sass_option_set_include_path (struct Sass_Options* options, const char* include_path);
+    # ADDAPI void ADDCALL sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);
+    # ADDAPI void ADDCALL sass_option_set_c_functions (struct Sass_Options* options, Sass_C_Function_List c_functions);
+    # ADDAPI void ADDCALL sass_option_set_c_importers (struct Sass_Options* options, Sass_Importer_List c_importers);
+    attach_function :sass_option_set_precision, [:sass_options_ptr, :int], :void
+    attach_function :sass_option_set_output_style, [:sass_options_ptr, SassOutputStyle], :void
+    attach_function :sass_option_set_source_comments, [:sass_options_ptr, :bool], :void
+    attach_function :sass_option_set_source_map_embed, [:sass_options_ptr, :bool], :void
+    attach_function :sass_option_set_source_map_contents, [:sass_options_ptr, :bool], :void
+    attach_function :sass_option_set_omit_source_map_url, [:sass_options_ptr, :bool], :void
+    attach_function :sass_option_set_is_indented_syntax_src, [:sass_options_ptr, :bool], :void
+    attach_function :sass_option_set_input_path, [:sass_options_ptr, :string], :void
+    attach_function :sass_option_set_output_path, [:sass_options_ptr, :string], :void
+    attach_function :sass_option_set_include_path, [:sass_options_ptr, :string], :void
+    attach_function :sass_option_set_source_map_file, [:sass_options_ptr, :string], :void
+    attach_function :sass_option_set_c_functions, [:sass_options_ptr, :pointer], :void
+    attach_function :sass_option_set_c_importers, [:sass_options_ptr, :pointer], :void
+    #attach_function :sass_option_set_c_importers, [:sass_options_ptr, :sass_importer], :void
+
+    # Getter for context
+    # ADDAPI const char* ADDCALL sass_context_get_output_string (struct Sass_Context* ctx);
+    # ADDAPI int ADDCALL sass_context_get_error_status (struct Sass_Context* ctx);
+    # ADDAPI const char* ADDCALL sass_context_get_error_json (struct Sass_Context* ctx);
+    # ADDAPI const char* ADDCALL sass_context_get_error_message (struct Sass_Context* ctx);
+    # ADDAPI const char* ADDCALL sass_context_get_error_file (struct Sass_Context* ctx);
+    # ADDAPI size_t ADDCALL sass_context_get_error_line (struct Sass_Context* ctx);
+    # ADDAPI size_t ADDCALL sass_context_get_error_column (struct Sass_Context* ctx);
+    # ADDAPI const char* ADDCALL sass_context_get_source_map_string (struct Sass_Context* ctx);
+    # ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx);
+    attach_function :sass_context_get_output_string, [:sass_context_ptr], :string
+    attach_function :sass_context_get_error_status, [:sass_context_ptr], :int
+    attach_function :sass_context_get_error_json, [:sass_context_ptr], :string
+    attach_function :sass_context_get_error_message, [:sass_context_ptr], :string
+    attach_function :sass_context_get_error_file, [:sass_context_ptr], :string
+    attach_function :sass_context_get_error_line, [:sass_context_ptr], :size_t
+    attach_function :sass_context_get_error_column, [:sass_context_ptr], :size_t
+    attach_function :sass_context_get_source_map_string, [:sass_context_ptr], :string
+    attach_function :_context_get_included_files, :sass_context_get_included_files, [:sass_context_ptr], :pointer
+
+    def self.context_get_included_files(*args)
+      return_string_array _context_get_included_files(*args)
+    end
+
+    # ADDAPI Sass_Import_Entry ADDCALL sass_compiler_get_last_import(struct Sass_Compiler* compiler);
+    attach_function :sass_compiler_get_last_import, [:pointer], :pointer
+  end
+end