sassc 2.1.0.pre1-x86-linux

data/lib/sassc/util/normalized_map.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+# A hash that normalizes its string keys while still allowing you to get back
+# to the original keys that were stored. If several different values normalize
+# to the same value, whichever is stored last wins.
+
+class SassC::Util::NormalizedMap
+
+  # Create a normalized map
+  def initialize(map = nil)
+    @key_strings = {}
+    @map = {}
+    map.each {|key, value| self[key] = value} if map
+  end
+
+  # Specifies how to transform the key.
+  # This can be overridden to create other normalization behaviors.
+  def normalize(key)
+    key.tr("-", "_")
+  end
+
+  # Returns the version of `key` as it was stored before
+  # normalization. If `key` isn't in the map, returns it as it was
+  # passed in.
+  # @return [String]
+  def denormalize(key)
+    @key_strings[normalize(key)] || key
+  end
+
+  # @private
+  def []=(k, v)
+    normalized = normalize(k)
+    @map[normalized] = v
+    @key_strings[normalized] = k
+    v
+  end
+
+  # @private
+  def [](k)
+    @map[normalize(k)]
+  end
+
+  # @private
+  def has_key?(k)
+    @map.has_key?(normalize(k))
+  end
+
+  # @private
+  def delete(k)
+    normalized = normalize(k)
+    @key_strings.delete(normalized)
+    @map.delete(normalized)
+  end
+
+  # @return [Hash] Hash with the keys as they were stored (before normalization).
+  def as_stored
+    SassC::Util.map_keys(@map) {|k| @key_strings[k]}
+  end
+
+  def empty?
+    @map.empty?
+  end
+
+  def values
+    @map.values
+  end
+
+  def keys
+    @map.keys
+  end
+
+  def each
+    @map.each {|k, v| yield(k, v)}
+  end
+
+  def size
+    @map.size
+  end
+
+  def to_hash
+    @map.dup
+  end
+
+  def to_a
+    @map.to_a
+  end
+
+  def map
+    @map.map {|k, v| yield(k, v)}
+  end
+
+  def dup
+    d = super
+    d.send(:instance_variable_set, "@map", @map.dup)
+    d
+  end
+
+  def sort_by
+    @map.sort_by {|k, v| yield k, v}
+  end
+
+  def update(map)
+    map = map.as_stored if map.is_a?(NormalizedMap)
+    map.each {|k, v| self[k] = v}
+  end
+
+  def method_missing(method, *args, &block)
+    @map.send(method, *args, &block)
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    @map.respond_to?(method, include_private)
+  end
+
+end

data/lib/sassc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SassC
+  VERSION = "2.1.0.pre1"
+end

data/sassc.gemspec

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sassc/version"
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "sassc"
+  spec.version       = SassC::VERSION
+  spec.authors       = ["Ryan Boland"]
+  spec.email         = ["ryan@tanookilabs.com"]
+  spec.summary       = "Use libsass with Ruby!"
+  spec.description   = "Use libsass with Ruby!"
+  spec.homepage      = "https://github.com/sass/sassc-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.required_ruby_version = ">= 2.3.3"
+
+  spec.require_paths = ["lib"]
+
+  spec.platform      = Gem::Platform::RUBY
+  spec.extensions    = ["ext/extconf.rb"]
+
+  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_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rake-compiler-dock"
+
+  spec.add_dependency "ffi", "~> 1.9"
+
+  gem_dir = File.expand_path(File.dirname(__FILE__)) + "/"
+
+  libsass_dir = File.join(gem_dir, 'ext', 'libsass')
+  if !File.directory?(libsass_dir)
+    $stderr.puts "Error: ext/libsass not checked out. Please run:\n\n"\
+                 "  git submodule update --init"
+    exit 1
+  end
+
+  Dir.chdir(libsass_dir) do
+    submodule_relative_path = File.join('ext', 'libsass')
+    `git ls-files`.split($\).each do |filename|
+      next if filename =~ %r{(^("?test|docs|script)/)|\.md$|\.yml$}
+      spec.files << File.join(submodule_relative_path, filename)
+    end
+  end
+
+end

data/test/custom_importer_test.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+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
+
+    class NoFilesImporter < Importer
+      def imports(path, parent_path)
+        []
+      end
+    end
+
+    class OptionsImporter < Importer
+      def imports(path, parent_path)
+        Import.new("name.scss", source: options[:custom_option_source])
+      end
+    end
+
+    class ParentImporter < Importer
+      def imports(path, parent_path)
+        Import.new("name.scss", source: ".#{parent_path} { color: red; }")
+      end
+    end
+
+    def test_custom_importer_works
+      temp_file("styles2.scss", ".hi { color: $var1; }")
+      temp_file("fonts.scss", ".font { color: $var1; }")
+
+      data = <<SCSS
+@import "styles";
+@import "fonts";
+SCSS
+
+      engine = Engine.new(data, {
+        importer: CustomImporter
+      })
+
+      assert_equal <<CSS, engine.render
+.hi {
+  color: #000; }
+
+.font {
+  color: #000; }
+CSS
+    end
+
+    def test_dependency_list
+      base = temp_dir("").to_s
+
+      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
+@import "styles";
+@import "fonts";
+SCSS
+
+      engine = Engine.new(data, {
+        importer: CustomImporter,
+        load_paths: ["fonts"]
+      })
+      engine.render
+
+      dependencies = engine.dependencies.map(&:filename).map { |f| f.gsub(base, "") }
+
+      assert_equal [
+        "/fonts/sub/sub_fonts.scss",
+        "/styles2.scss",
+        "fonts/fonts.scss",
+        "styles1.scss"
+      ], dependencies
+    end
+
+    def test_custom_importer_works_with_no_files
+      engine = Engine.new("@import 'fake.scss';", {
+        importer: NoFilesImporter
+      })
+
+      assert_equal "", engine.render
+    end
+
+    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
+.test {
+  width: 30px; }
+CSS
+    end
+
+    def test_parent_path_is_accessible
+      engine = Engine.new("@import 'parent.scss';", {
+        importer: ParentImporter,
+        filename: "import-parent-filename.scss"
+      })
+
+      assert_equal <<CSS, engine.render
+.import-parent-filename.scss {
+  color: red; }
+CSS
+    end
+  end
+end

data/test/engine_test.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+module SassC
+  class EngineTest < MiniTest::Test
+    include TempFileTest
+
+    def render(data)
+      Engine.new(data).render
+    end
+
+    def test_line_comments
+      template = <<-SCSS
+.foo {
+  baz: bang; }
+      SCSS
+      expected_output = <<-CSS
+/* line 1, stdin */
+.foo {
+  baz: bang; }
+      CSS
+      output = Engine.new(template, line_comments: true).render
+      assert_equal expected_output, output
+    end
+
+    def test_one_line_comments
+      assert_equal <<CSS, render(<<SCSS)
+.foo {
+  baz: bang; }
+CSS
+.foo {// bar: baz;}
+  baz: bang; //}
+}
+SCSS
+      assert_equal <<CSS, render(<<SCSS)
+.foo bar[val="//"] {
+  baz: bang; }
+CSS
+.foo bar[val="//"] {
+  baz: bang; //}
+}
+SCSS
+  end
+
+    def test_variables
+      assert_equal <<CSS, render(<<SCSS)
+blat {
+  a: foo; }
+CSS
+$var: foo;
+
+blat {a: $var}
+SCSS
+
+      assert_equal <<CSS, render(<<SCSS)
+foo {
+  a: 2;
+  b: 6; }
+CSS
+foo {
+  $var: 2;
+  $another-var: 4;
+  a: $var;
+  b: $var + $another-var;}
+SCSS
+    end
+
+    def test_precision
+      template = <<-SCSS
+$var: 1;
+.foo {
+  baz: $var / 3; }
+SCSS
+      expected_output = <<-CSS
+.foo {
+  baz: 0.33333333; }
+CSS
+      output = Engine.new(template, precision: 8).render
+      assert_equal expected_output, output
+    end
+
+    def test_precision_not_specified
+      template = <<-SCSS
+$var: 1;
+.foo {
+  baz: $var / 3; }
+SCSS
+      expected_output = <<-CSS
+.foo {
+  baz: 0.3333333333; }
+CSS
+      output = Engine.new(template).render
+      assert_equal expected_output, output
+    end
+
+    def test_dependency_filenames_are_reported
+      base = temp_dir("").to_s
+
+      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 = Engine.new(File.read("styles.scss"))
+      engine.render
+      deps = engine.dependencies
+
+      expected = ["/import.scss", "/import_parent.scss"]
+      assert_equal expected, deps.map { |dep| dep.options[:filename].gsub(base, "") }.sort
+      assert_equal expected, deps.map { |dep| dep.filename.gsub(base, "") }.sort
+    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 = Engine.new("$size: 30px;")
+      assert_raises(NotRenderedError) { engine.dependencies }
+    end
+
+    def test_source_map
+      temp_dir('admin')
+
+      temp_file('admin/text-color.scss', <<SCSS)
+p {
+  color: red;
+}
+SCSS
+      temp_file('style.scss', <<SCSS)
+@import 'admin/text-color';
+
+p {
+  padding: 20px;
+}
+SCSS
+      engine = Engine.new(File.read('style.scss'), {
+        source_map_file: "style.scss.map",
+        source_map_contents: true
+      })
+      engine.render
+
+      assert_equal <<MAP.strip, engine.source_map
+{
+\t"version": 3,
+\t"file": "stdin.css",
+\t"sources": [
+\t\t"stdin",
+\t\t"admin/text-color.scss"
+\t],
+\t"sourcesContent": [
+\t\t"@import 'admin/text-color';\\n\\np {\\n  padding: 20px;\\n}\\n",
+\t\t"p {\\n  color: red;\\n}\\n"
+\t],
+\t"names": [],
+\t"mappings": "ACAA,AAAA,CAAC,CAAC;EACA,KAAK,EAAE,GAAG,GACX;;ADAD,AAAA,CAAC,CAAC;EACA,OAAO,EAAE,IAAI,GACd"
+}
+MAP
+    end
+
+    def test_no_source_map
+      engine = Engine.new("$size: 30px;")
+      engine.render
+      assert_raises(NotRenderedError) { engine.source_map }
+    end
+
+    def test_omit_source_map_url
+      temp_file('style.scss', <<SCSS)
+p {
+  padding: 20px;
+}
+SCSS
+      engine = Engine.new(File.read('style.scss'), {
+        source_map_file: "style.scss.map",
+        source_map_contents: true,
+        omit_source_map_url: true
+      })
+      output = engine.render
+
+      refute_match /sourceMappingURL/, output
+    end
+
+    def test_load_paths
+      temp_dir("included_1")
+      temp_dir("included_2")
+
+      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", Engine.new(
+        File.read("styles.scss"),
+        load_paths: [ "included_1", "included_2" ]
+      ).render
+    end
+
+    def test_global_load_paths
+      temp_dir("included_1")
+      temp_dir("included_2")
+
+      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; }")
+
+      ::SassC.load_paths << "included_1"
+      ::SassC.load_paths << "included_2"
+
+      assert_equal ".hi {\n  width: 30px; }\n", Engine.new(
+        File.read("styles.scss"),
+      ).render
+      ::SassC.load_paths.clear
+    end
+
+    def test_env_load_paths
+      expected_load_paths = [ "included_1", "included_2" ]
+      ::SassC.instance_eval { @load_paths = nil }
+      ENV['SASS_PATH'] = expected_load_paths.join(File::PATH_SEPARATOR)
+      assert_equal expected_load_paths, ::SassC.load_paths
+      ::SassC.load_paths.clear
+    end
+
+    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(SyntaxError) do
+        Engine.new(File.read("styles.scss")).render
+      end
+    end
+
+    def test_sass_variation
+      sass = <<SASS
+$size: 30px
+.foo
+  width: $size
+SASS
+
+    css = <<CSS
+.foo {
+  width: 30px; }
+CSS
+
+      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
+
+    def test_encoding_matches_input
+      input = String.new("$size: 30px;")
+      input.force_encoding("UTF-8")
+      output = Engine.new(input).render
+      assert_equal input.encoding, output.encoding
+    end
+
+    def test_inline_source_maps
+      template = <<-SCSS
+.foo {
+  baz: bang; }
+      SCSS
+      expected_output = <<-CSS
+/* line 1, stdin */
+.foo {
+  baz: bang; }
+      CSS
+
+      output = Engine.new(template, {
+        source_map_file: ".",
+        source_map_embed: true,
+        source_map_contents: true
+      }).render
+
+      assert_match /sourceMappingURL/, output
+      assert_match /.foo/, output
+    end
+
+    def test_empty_template
+      output = Engine.new('').render
+      assert_equal '', output
+    end
+
+    def test_empty_template_returns_a_new_object
+      input = String.new
+      output = Engine.new(input).render
+      assert input.object_id != output.object_id, 'empty template must return a new object'
+    end
+
+    def test_empty_template_encoding_matches_input
+      input = String.new.force_encoding("ISO-8859-1")
+      output = Engine.new(input).render
+      assert_equal input.encoding, output.encoding
+    end
+
+    def test_handling_of_frozen_strings
+      output = Engine.new("body { background-color: red; }".freeze).render
+      assert_equal output, "body {\n  background-color: red; }\n"
+    end
+
+    def test_import_plain_css
+      temp_file("test.css", ".something{color: red}")
+      expected_output = <<-CSS
+.something {
+  color: red; }
+      CSS
+
+      output = Engine.new("@import 'test'").render
+      assert_equal expected_output, output
+    end
+  end
+end