sass 3.4.25 → 3.7.4

data/lib/sass/script/css_variable_warning.rb

@@ -1,52 +0,0 @@
-module Sass
-  module Script
-    # An object tracking whether a warning has been emitted for a given script
-    # tree.
-    #
-    # This is shared among all objects in a script tree. Whenever any of those
-    # objects encounters a situation in which it wouldn't produce semantically
-    # identical CSS to its input, it calls \{#warn!\}. The first time \{#warn!}
-    # is called for a given warning object, it prints a deprecation warning.
-    class CssVariableWarning
-      def initialize
-        @warned = false
-        @value = nil
-      end
-
-      # Sets the root of the script tree that this warning refers to.
-      #
-      # @param value [Sass::Script::Tree::Node]
-      def value=(value)
-        warn_called = @warned && !@value
-        @value = value
-        print_warning if warn_called
-      end
-
-      # The first time this is called, it prints a deprecation warning.
-      #
-      # This may be called before \{#value=}. If it is, the warning is emitted
-      # once the script tree is set.
-      def warn!
-        return if @warned
-        @warned = true
-        return unless @value
-
-        print_warning
-      end
-
-      private
-
-      # Prints this node's warning.
-      def print_warning
-        of_filename = " of #{@value.filename}" if @value.filename
-        Sass::Util.sass_warn(
-          "DEPRECATION WARNING on line #{@value.line}#{of_filename}:\n" +
-          "Sass 3.6 will change the way CSS variables are parsed. Instead of being parsed as\n" +
-          "normal properties, they will not allow any Sass-specific behavior other than \#{}.\n" +
-          "For forwards-compatibility, use \#{}:\n" +
-          "\n" +
-          "  --variable: \#{#{@value.to_sass}};")
-      end
-    end
-  end
-end

data/lib/sass/util/cross_platform_random.rb

@@ -1,19 +0,0 @@
-module Sass
-  module Util
-    # Ruby 1.8 doesn't support an actual Random class with a settable seed.
-    class CrossPlatformRandom
-      def initialize(seed = nil)
-        if Sass::Util.ruby1_8?
-          srand(seed) if seed
-        else
-          @random = seed ? ::Random.new(seed) : ::Random.new
-        end
-      end
-
-      def rand(*args)
-        return @random.rand(*args) if @random
-        Kernel.rand(*args)
-      end
-    end
-  end
-end

data/lib/sass/util/ordered_hash.rb

@@ -1,192 +0,0 @@
-# Copyright (c) 2005-2013 David Heinemeier Hansson
-#
-# 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.
-
-# This class was copied from an old version of ActiveSupport.
-class OrderedHash < ::Hash
-  # In MRI the Hash class is core and written in C. In particular, methods are
-  # programmed with explicit C function calls and polymorphism is not honored.
-  #
-  # For example, []= is crucial in this implementation to maintain the @keys
-  # array but hash.c invokes rb_hash_aset() originally. This prevents method
-  # reuse through inheritance and forces us to reimplement stuff.
-  #
-  # For instance, we cannot use the inherited #merge! because albeit the algorithm
-  # itself would work, our []= is not being called at all by the C code.
-
-  def initialize(*args)
-    super
-    @keys = []
-  end
-
-  def self.[](*args)
-    ordered_hash = new
-
-    if args.length == 1 && args.first.is_a?(Array)
-      args.first.each do |key_value_pair|
-        next unless key_value_pair.is_a?(Array)
-        ordered_hash[key_value_pair[0]] = key_value_pair[1]
-      end
-
-      return ordered_hash
-    end
-
-    unless args.size.even?
-      raise ArgumentError.new("odd number of arguments for Hash")
-    end
-
-    args.each_with_index do |val, ind|
-      next if ind.odd?
-      ordered_hash[val] = args[ind + 1]
-    end
-
-    ordered_hash
-  end
-
-  def initialize_copy(other)
-    super
-    # make a deep copy of keys
-    @keys = other.keys
-  end
-
-  def []=(key, value)
-    @keys << key unless has_key?(key)
-    super
-  end
-
-  def delete(key)
-    if has_key? key
-      index = @keys.index(key)
-      @keys.delete_at index
-    end
-    super
-  end
-
-  def delete_if
-    super
-    sync_keys!
-    self
-  end
-
-  def reject!
-    super
-    sync_keys!
-    self
-  end
-
-  def reject
-    dup.reject! {|h, k| yield h, k}
-  end
-
-  def keys
-    @keys.dup
-  end
-
-  def values
-    @keys.map {|key| self[key]}
-  end
-
-  def to_hash
-    self
-  end
-
-  def to_a
-    @keys.map {|key| [key, self[key]]}
-  end
-
-  def each_key
-    return to_enum(:each_key) unless block_given?
-    @keys.each {|key| yield key}
-    self
-  end
-
-  def each_value
-    return to_enum(:each_value) unless block_given?
-    @keys.each {|key| yield self[key]}
-    self
-  end
-
-  def each
-    return to_enum(:each) unless block_given?
-    @keys.each {|key| yield [key, self[key]]}
-    self
-  end
-
-  def each_pair
-    return to_enum(:each_pair) unless block_given?
-    @keys.each {|key| yield key, self[key]}
-    self
-  end
-
-  alias_method :select, :find_all
-
-  def clear
-    super
-    @keys.clear
-    self
-  end
-
-  def shift
-    k = @keys.first
-    v = delete(k)
-    [k, v]
-  end
-
-  def merge!(other_hash)
-    if block_given?
-      other_hash.each {|k, v| self[k] = key?(k) ? yield(k, self[k], v) : v}
-    else
-      other_hash.each {|k, v| self[k] = v}
-    end
-    self
-  end
-
-  alias_method :update, :merge!
-
-  def merge(other_hash)
-    if block_given?
-      dup.merge!(other_hash) {|k, v1, v2| yield k, v1, v2}
-    else
-      dup.merge!(other_hash)
-    end
-  end
-
-  # When replacing with another hash, the initial order of our keys must come from the other hash --
-  # ordered or not.
-  def replace(other)
-    super
-    @keys = other.keys
-    self
-  end
-
-  def invert
-    OrderedHash[to_a.map! {|key_value_pair| key_value_pair.reverse}]
-  end
-
-  def inspect
-    "#<OrderedHash #{super}>"
-  end
-
-  private
-
-  def sync_keys!
-    @keys.delete_if {|k| !has_key?(k)}
-  end
-end

data/test/sass-spec.yml

@@ -1,3 +0,0 @@
----
-:enabled: true
-:language_version: '3.4'

data/test/sass/cache_test.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/test_helper'
-require 'sass/engine'
-
-class CacheTest < MiniTest::Test
-  @@cache_dir = "tmp/file_cache"
-
-  def setup
-    FileUtils.mkdir_p @@cache_dir
-  end
-
-  def teardown
-    FileUtils.rm_rf @@cache_dir
-    clean_up_sassc
-  end
-
-  def test_file_cache_writes_a_file
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-  end
-
-  def test_file_cache_reads_a_file
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    assert_kind_of Sass::Tree::RootNode, file_store.retrieve("asdf/foo.scssc", "fakesha1")
-  end
-
-  def test_file_cache_miss_returns_nil
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
-  end
-
-  def test_sha_change_invalidates_cache_and_cleans_up
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    assert_nil file_store.retrieve("asdf/foo.scssc", "differentsha1")
-    assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-  end
-
-  def test_version_change_invalidates_cache_and_cleans_up
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    real_version = Sass::VERSION
-    begin
-      Sass::VERSION.replace("a different version")
-      assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
-      assert !File.exist?("#{@@cache_dir}/asdf/foo.scssc")
-    ensure
-      Sass::VERSION.replace(real_version)
-    end
-  end
-
-  def test_arbitrary_objects_can_go_into_cache
-    cache = Sass::CacheStores::Memory.new
-    an_object = {:foo => :bar}
-    cache.store("an_object", "", an_object)
-    assert_equal an_object, cache.retrieve("an_object", "")
-  end
-
-  def test_cache_node_with_unmarshalable_option
-    engine_with_unmarshalable_options("foo {a: b + c}").to_tree
-  end
-
-  # Regression tests
-
-  def test_cache_mixin_def_splat_sass_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SASS, :syntax => :sass).to_tree
-=color($args...)
-  color: red
-SASS
-  end
-
-  def test_cache_mixin_def_splat_scss_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SCSS, :syntax => :scss).to_tree
-@mixin color($args...) {
-  color: red;
-}
-SCSS
-  end
-
-  def test_cache_function_splat_sass_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SASS, :syntax => :sass).to_tree
-@function color($args...)
-  @return red
-SASS
-  end
-
-  def test_cache_function_splat_scss_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SCSS, :syntax => :scss).to_tree
-@function color($args...) {
-  @return red;
-}
-SCSS
-  end
-
-  def test_cache_include_splat_sass_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SASS, :syntax => :sass).to_tree
-@include color($args..., $kwargs...)
-SASS
-  end
-
-  def test_cache_include_splat_scss_node_with_unmarshalable_option
-    engine_with_unmarshalable_options(<<SCSS, :syntax => :scss).to_tree
-@include color($args..., $kwargs...);
-SCSS
-  end
-
-  private
-  def root_node
-    Sass::Engine.new(<<-SCSS, :syntax => :scss).to_tree
-      @mixin color($c) { color: $c}
-      div { @include color(red); }
-    SCSS
-  end
-
-  def engine_with_unmarshalable_options(src, options={})
-    Sass::Engine.new(src, {
-      :syntax => :scss, :object => Class.new.new, :filename => 'file.scss',
-      :importer => Sass::Importers::Filesystem.new(absolutize('templates'))
-    }.merge(options))
-  end
-end

data/test/sass/callbacks_test.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
-require 'sass/callbacks'
-
-class CallerBack
-  extend Sass::Callbacks
-  define_callback :foo
-  define_callback :bar
-
-  def do_foo
-    run_foo
-  end
-
-  def do_bar
-    run_bar 12
-  end
-end
-
-module ClassLevelCallerBack
-  extend Sass::Callbacks
-  define_callback :foo
-  extend self
-
-  def do_foo
-    run_foo
-  end
-end
-
-class SassCallbacksTest < MiniTest::Test
-  def test_simple_callback
-    cb = CallerBack.new
-    there = false
-    cb.on_foo {there = true}
-    cb.do_foo
-    assert there, "Expected callback to be called."
-  end
-
-  def test_multiple_callbacks
-    cb = CallerBack.new
-    str = ""
-    cb.on_foo {str += "first"}
-    cb.on_foo {str += " second"}
-    cb.do_foo
-    assert_equal "first second", str
-  end
-
-  def test_callback_with_arg
-    cb = CallerBack.new
-    val = nil
-    cb.on_bar {|a| val = a}
-    cb.do_bar
-    assert_equal 12, val
-  end
-
-  def test_class_level_callback
-    there = false
-    ClassLevelCallerBack.on_foo {there = true}
-    ClassLevelCallerBack.do_foo
-    assert there, "Expected callback to be called."
-  end
-end