sassc 0.0.10 → 0.0.11

data/lib/sassc/import_handler.rb

@@ -1,4 +1,45 @@
 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, :string, :pointer]) do |path, parent_path, cookie|
+        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/lib/sassc/importer.rb

@@ -2,41 +2,14 @@ module SassC
   class Importer
     attr_reader :options
 
-    def imports(path, parent_path)
-      # A custom importer must override this method.
-      raise NotImplementedError
-    end
-
-    def setup(native_options)
-      @function = FFI::Function.new(:pointer, [:string, :string, :pointer]) do |path, parent_path, cookie|
-        imports = [*imports(path, parent_path)]
-        self.class.imports_to_native(imports)
-      end
-
-      callback = SassC::Native.make_importer(@function, nil)
-      SassC::Native.option_set_importer(native_options, callback)
-    end
-
     def initialize(options)
       @options = options
     end
 
-    def self.empty_imports
-      SassC::Native.make_import_list(0)
-    end
-
-    def self.imports_to_native(imports)
-      import_list = SassC::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 = SassC::Native.make_import_entry(import.path, source, source_map_path)
-        SassC::Native.import_set_list_entry(import_list, i, entry)
-      end
-
-      import_list
+    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

data/lib/sassc/native.rb

@@ -49,7 +49,7 @@ module SassC
 
     def self.native_string(string)
       string += "\0"
-      data = SassC::Native::LibC.malloc(string.size)
+      data = Native::LibC.malloc(string.size)
       data.write_string(string)
       data
     end

data/lib/sassc/native/native_context_api.rb

@@ -99,7 +99,7 @@ module SassC
     # 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_importer (struct Sass_Options* options, Sass_C_Import_Callback importer);
+    # 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
@@ -112,7 +112,8 @@ module SassC
     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_importer, [:sass_options_ptr, :sass_importer], :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);

data/lib/sassc/script.rb

@@ -6,57 +6,6 @@ module SassC
       end
     end
 
-    def self.setup_custom_functions(options, sass_options)
-      callbacks = {}
-
-      list = Native.make_function_list(custom_functions.count)
-
-      functs = Class.new.extend(Functions)
-      def functs.options=(opts)
-        @sass_options = opts
-      end
-      def functs.options
-        @sass_options
-      end
-      functs.options = sass_options
-
-      custom_functions.each_with_index do |custom_function, i|
-        callbacks[custom_function] = FFI::Function.new(:pointer, [:pointer, :pointer]) do |s_args, cookie|
-          length = Native.list_get_length(s_args)
-
-          v = Native.list_get_value(s_args, 0)
-          v = Native.string_get_value(v).dup
-
-          s = String.new(String.unquote(v), String.type(v))
-
-          value = functs.send(custom_function, s)
-
-          if value
-            value = String.new(String.unquote(value.to_s), value.type)
-            value.to_native
-          else
-            String.new("").to_native
-          end
-        end
-
-        callback = Native.make_function(
-          formatted_function_name(custom_function),
-          callbacks[custom_function],
-          nil
-        )
-
-        Native::function_set_list_entry(list, i, callback)
-      end
-
-      Native::option_set_c_functions(options, list)
-
-      status = yield
-
-      callbacks
-
-      status
-    end
-
     def self.formatted_function_name(function_name)
       params = Functions.instance_method(function_name).parameters
       params = params.select { |param| param[0] == :req }

data/lib/sassc/version.rb

@@ -1,3 +1,3 @@
 module SassC
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/sassc.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.5.1"
   spec.add_development_dependency "minitest-around"
   spec.add_development_dependency "test_construct"
+  spec.add_development_dependency "pry"
 
   spec.add_dependency "bundler"
   spec.add_dependency "ffi", "~> 1.9.6"

data/test/custom_importer_test.rb

@@ -1,109 +1,112 @@
 require_relative "test_helper"
 
-class FunctionsTest < SassCTest
-  class CustomImporter < SassC::Importer
-    def imports(path, parent_path)
-      if path =~ /styles/
-        [
-          Import.new("#{path}1.scss", source: "$var1: #000;"),
-          Import.new("#{path}2.scss")
-        ]
-      else
-        Import.new(path)
+module SassC
+  class CustomImporterTest < MiniTest::Test
+    include TempFileTest
+
+    class CustomImporter < Importer
+      def imports(path, parent_path)
+        if path =~ /styles/
+          [
+            Import.new("#{path}1.scss", source: "$var1: #000;"),
+            Import.new("#{path}2.scss")
+          ]
+        else
+          Import.new(path)
+        end
       end
     end
-  end
 
-  class NoFilesImporter < SassC::Importer
-    def imports(path, parent_path)
-      []
-    end
-  end
-
-  class OptionsImporter < SassC::Importer
-    def imports(path, parent_path)
-      Import.new("name.scss", source: options[:custom_option_source])
+    class NoFilesImporter < Importer
+      def imports(path, parent_path)
+        []
+      end
     end
-  end
 
-  def around
-    within_construct do |construct|
-      @construct = construct
-      yield
+    class OptionsImporter < Importer
+      def imports(path, parent_path)
+        Import.new("name.scss", source: options[:custom_option_source])
+      end
     end
 
-    @construct = nil
-  end
+    def test_custom_importer_works
+      temp_file("styles2.scss", ".hi { color: $var1; }")
+      temp_file("fonts.scss", ".font { color: $var1; }")
 
-  def test_custom_importer_works
-    @construct.file("styles2.scss", ".hi { color: $var1; }")
-    @construct.file("fonts.scss", ".font { color: $var1; }")
-
-    data = <<SCSS
+      data = <<SCSS
 @import "styles";
 @import "fonts";
 SCSS
 
-    engine = SassC::Engine.new(data, {
-      importer: CustomImporter
-    })
+      engine = Engine.new(data, {
+        importer: CustomImporter
+      })
 
-    assert_equal <<CSS, engine.render
+      assert_equal <<CSS, engine.render
 .hi {
   color: #000; }
 
 .font {
   color: #000; }
 CSS
-  end
+    end
 
-  def test_dependency_list
-    @construct.file("styles2.scss", ".hi { color: $var1; }")
-    @construct.file("fonts.scss", ".font { color: $var1; }")
+    def test_dependency_list
+      temp_dir("fonts")
+      temp_dir("fonts/sub")
+      temp_file("fonts/sub/sub_fonts.scss", "$font: arial;")
+      temp_file("styles2.scss", ".hi { color: $var1; }")
+      temp_file "fonts/fonts.scss", <<SCSS
+@import "sub/sub_fonts";
+.font { font-familiy: $font; color: $var1; }
+SCSS
 
-    data = <<SCSS
+      data = <<SCSS
 @import "styles";
 @import "fonts";
 SCSS
 
-    engine = SassC::Engine.new(data, {
-      importer: CustomImporter
-    })
-    engine.render
+      engine = Engine.new(data, {
+        importer: CustomImporter,
+        load_paths: ["fonts"]
+      })
+      engine.render
 
-    dependencies = engine.dependencies.map(&:options).map { |o| o[:filename] }
+      dependencies = engine.dependencies.map(&:filename)
 
-    # TODO: this behavior is kind of weird (styles1.scss is not included)
-    # not sure why.
+      # TODO: this behavior is kind of weird (styles1.scss is not included)
+      # not sure why.
 
-    assert_equal [
-      "fonts.scss",
-      "styles",
-      "styles2.scss"
-    ], dependencies
-  end
+      assert_equal [
+        "fonts/fonts.scss",
+        "fonts/sub/sub_fonts.scss",
+        "styles",
+        "styles2.scss"
+      ], dependencies
+    end
 
-  def test_custom_importer_works_with_no_files
-    engine = SassC::Engine.new("@import 'fake.scss';", {
-      importer: NoFilesImporter
-    })
+    def test_custom_importer_works_with_no_files
+      engine = Engine.new("@import 'fake.scss';", {
+        importer: NoFilesImporter
+      })
 
-    assert_equal "", engine.render
-  end
+      assert_equal "", engine.render
+    end
 
-  def test_custom_importer_can_access_sassc_options
-    engine = SassC::Engine.new("@import 'fake.scss';", {
-      importer: OptionsImporter,
-      custom_option_source: ".test { width: 30px; }"
-    })
+    def test_custom_importer_can_access_sassc_options
+      engine = Engine.new("@import 'fake.scss';", {
+        importer: OptionsImporter,
+        custom_option_source: ".test { width: 30px; }"
+      })
 
-    assert_equal <<CSS, engine.render
+      assert_equal <<CSS, engine.render
 .test {
   width: 30px; }
 CSS
-  end
+    end
 
-  def test_parent_path_is_accessible
-    skip "TBD"
+    def test_parent_path_is_accessible
+      skip "TBD"
+    end
   end
 end

data/test/engine_test.rb

@@ -1,12 +1,15 @@
 require_relative "test_helper"
 
-class EngineTest < SassCTest
-  def render(data)
-    SassC::Engine.new(data).render
-  end
+module SassC
+  class EngineTest < MiniTest::Test
+    include TempFileTest
+
+    def render(data)
+      Engine.new(data).render
+    end
 
-  def test_one_line_comments
-    assert_equal <<CSS, render(<<SCSS)
+    def test_one_line_comments
+      assert_equal <<CSS, render(<<SCSS)
 .foo {
   baz: bang; }
 CSS
@@ -14,7 +17,7 @@ CSS
   baz: bang; //}
 }
 SCSS
-    assert_equal <<CSS, render(<<SCSS)
+      assert_equal <<CSS, render(<<SCSS)
 .foo bar[val="//"] {
   baz: bang; }
 CSS
@@ -24,8 +27,8 @@ CSS
 SCSS
   end
 
-  def test_variables
-    assert_equal <<CSS, render(<<SCSS)
+    def test_variables
+      assert_equal <<CSS, render(<<SCSS)
 blat {
   a: foo; }
 CSS
@@ -34,7 +37,7 @@ $var: foo;
 blat {a: $var}
 SCSS
 
-    assert_equal <<CSS, render(<<SCSS)
+      assert_equal <<CSS, render(<<SCSS)
 foo {
   a: 2;
   b: 6; }
@@ -45,66 +48,61 @@ foo {
   a: $var;
   b: $var + $another-var;}
 SCSS
-  end
+    end
 
-  def test_dependency_filenames_are_reported
-    within_construct do |construct|
-      construct.file("not_included.scss", "$size: 30px;")
-      construct.file("import_parent.scss", "$size: 30px;")
-      construct.file("import.scss", "@import 'import_parent'; $size: 30px;")
-      construct.file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+    def test_dependency_filenames_are_reported
+      temp_file("not_included.scss", "$size: 30px;")
+      temp_file("import_parent.scss", "$size: 30px;")
+      temp_file("import.scss", "@import 'import_parent'; $size: 30px;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
 
-      engine = SassC::Engine.new(File.read("styles.scss"))
+      engine = Engine.new(File.read("styles.scss"))
       engine.render
       deps = engine.dependencies
-      filenames = deps.map { |dep| dep.options[:filename] }.sort
 
-      assert_equal ["import.scss", "import_parent.scss"], filenames
+      expected = ["import.scss", "import_parent.scss"]
+      assert_equal expected, deps.map { |dep| dep.options[:filename] }.sort
+      assert_equal expected, deps.map(&:filename).sort
     end
-  end
 
-  def test_no_dependencies
-    engine = SassC::Engine.new("$size: 30px;")
-    engine.render
-    deps = engine.dependencies
-    assert_equal [], deps
-  end
+    def test_no_dependencies
+      engine = Engine.new("$size: 30px;")
+      engine.render
+      deps = engine.dependencies
+      assert_equal [], deps
+    end
 
-  def test_not_rendered_error
-    engine = SassC::Engine.new("$size: 30px;")
-    assert_raises(SassC::Engine::NotRenderedError) { engine.dependencies }
-  end
+    def test_not_rendered_error
+      engine = Engine.new("$size: 30px;")
+      assert_raises(NotRenderedError) { engine.dependencies }
+    end
 
-  def test_load_paths
-    within_construct do |c|
-      c.directory("included_1")
-      c.directory("included_2")
+    def test_load_paths
+      temp_dir("included_1")
+      temp_dir("included_2")
 
-      c.file("included_1/import_parent.scss", "$s: 30px;")
-      c.file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
-      c.file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+      temp_file("included_1/import_parent.scss", "$s: 30px;")
+      temp_file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
 
-      assert_equal ".hi {\n  width: 30px; }\n", SassC::Engine.new(
+      assert_equal ".hi {\n  width: 30px; }\n", Engine.new(
         File.read("styles.scss"),
         load_paths: [ "included_1", "included_2" ]
       ).render
     end
-  end
 
-  def test_load_paths_not_configured
-    within_construct do |c|
-      c.file("included_1/import_parent.scss", "$s: 30px;")
-      c.file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
-      c.file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
+    def test_load_paths_not_configured
+      temp_file("included_1/import_parent.scss", "$s: 30px;")
+      temp_file("included_2/import.scss", "@import 'import_parent'; $size: $s;")
+      temp_file("styles.scss", "@import 'import.scss'; .hi { width: $size; }")
 
-      assert_raises(SassC::SyntaxError) {
-        SassC::Engine.new(File.read("styles.scss")).render
-      }
+      assert_raises(SyntaxError) do
+        Engine.new(File.read("styles.scss")).render
+      end
     end
-  end
 
-  def test_sass_variation
-    sass = <<SASS
+    def test_sass_variation
+      sass = <<SASS
 $size: 30px
 .foo
   width: $size
@@ -115,8 +113,9 @@ SASS
   width: 30px; }
 CSS
 
-    assert_equal css, SassC::Engine.new(sass, syntax: :sass).render
-    assert_equal css, SassC::Engine.new(sass, syntax: "sass").render
-    assert_raises(SassC::SyntaxError) { SassC::Engine.new(sass).render }
+      assert_equal css, Engine.new(sass, syntax: :sass).render
+      assert_equal css, Engine.new(sass, syntax: "sass").render
+      assert_raises(SyntaxError) { Engine.new(sass).render }
+    end
   end
 end