haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/lib/sass/util/subset_map.rb

@@ -1,101 +0,0 @@
-require 'set'
-
-module Sass
-  module Util
-    # A map from sets to values.
-    # A value is \{#\[]= set} by providing a set (the "set-set") and a value,
-    # which is then recorded as corresponding to that set.
-    # Values are \{#\[] accessed} by providing a set (the "get-set")
-    # and returning all values that correspond to set-sets
-    # that are subsets of the get-set.
-    #
-    # SubsetMap preserves the order of values as they're inserted.
-    #
-    # @example
-    #   ssm = SubsetMap.new
-    #   ssm[Set[1, 2]] = "Foo"
-    #   ssm[Set[2, 3]] = "Bar"
-    #   ssm[Set[1, 2, 3]] = "Baz"
-    #
-    #   ssm[Set[1, 2, 3]] #=> ["Foo", "Bar", "Baz"]
-    class SubsetMap
-      # Creates a new, empty SubsetMap.
-      def initialize
-        @hash = {}
-        @vals = []
-      end
-
-      # Whether or not this SubsetMap has any key-value pairs.
-      #
-      # @return [Boolean]
-      def empty?
-        @hash.empty?
-      end
-
-      # Associates a value with a set.
-      # When `set` or any of its supersets is accessed,
-      # `value` will be among the values returned.
-      #
-      # Note that if the same `set` is passed to this method multiple times,
-      # all given `value`s will be associated with that `set`.
-      #
-      # This runs in `O(n)` time, where `n` is the size of `set`.
-      #
-      # @param set [#to_set] The set to use as the map key. May not be empty.
-      # @param value [Object] The value to associate with `set`.
-      # @raise [ArgumentError] If `set` is empty.
-      def []=(set, value)
-        raise ArgumentError.new("SubsetMap keys may not be empty.") if set.empty?
-
-        index = @vals.size
-        @vals << value
-        set.each do |k|
-          @hash[k] ||= []
-          @hash[k] << [set, set.to_set, index]
-        end
-      end
-
-      # Returns all values associated with subsets of `set`.
-      #
-      # In the worst case, this runs in `O(m*max(n, log m))` time,
-      # where `n` is the size of `set`
-      # and `m` is the number of assocations in the map.
-      # However, unless many keys in the map overlap with `set`,
-      # `m` will typically be much smaller.
-      #
-      # @param set [Set] The set to use as the map key.
-      # @return [Array<(Object, #to_set)>] An array of pairs,
-      #   where the first value is the value associated with a subset of `set`,
-      #   and the second value is that subset of `set`
-      #   (or whatever `#to_set` object was used to set the value)
-      #   This array is in insertion order.
-      # @see #[]
-      def get(set)
-        res = set.map do |k|
-          next unless subsets = @hash[k]
-          subsets.map do |subenum, subset, index|
-            next unless subset.subset?(set)
-            [index, subenum]
-          end
-        end
-        res = Sass::Util.flatten(res, 1)
-        res.compact!
-        res.uniq!
-        res.sort!
-        res.map! {|i, s| [@vals[i], s]}
-        return res
-      end
-
-      # Same as \{#get}, but doesn't return the subsets of the argument
-      # for which values were found.
-      #
-      # @param set [Set] The set to use as the map key.
-      # @return [Array] The array of all values
-      #   associated with subsets of `set`, in insertion order.
-      # @see #get
-      def [](set)
-        get(set).map {|v, _| v}
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/version.rb

@@ -1,112 +0,0 @@
-# This is necessary for loading Sass when Haml is required in Rails 3.
-# Once the split is complete, we can remove it.
-require File.dirname(__FILE__) + '/../sass'
-require 'sass/util'
-
-module Sass
-  # Handles Sass version-reporting.
-  # Sass not only reports the standard three version numbers,
-  # but its Git revision hash as well,
-  # if it was installed from Git.
-  module Version
-    include Sass::Util
-
-    # Returns a hash representing the version of Sass.
-    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
-    # The `:name` key has the name of the version.
-    # The `:string` key contains a human-readable string representation of the version.
-    # The `:number` key is the major, minor, and teeny keys separated by periods.
-    # If Sass is checked out from Git, the `:rev` key will have the revision hash.
-    # For example:
-    #
-    #     {
-    #       :string => "2.1.0.9616393",
-    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
-    #       :number => "2.1.0",
-    #       :major  => 2, :minor => 1, :teeny => 0
-    #     }
-    #
-    # If a prerelease version of Sass is being used,
-    # the `:string` and `:number` fields will reflect the full version
-    # (e.g. `"2.2.beta.1"`), and the `:teeny` field will be `-1`.
-    # A `:prerelease` key will contain the name of the prerelease (e.g. `"beta"`),
-    # and a `:prerelease_number` key will contain the rerelease number.
-    # For example:
-    #
-    #     {
-    #       :string => "3.0.beta.1",
-    #       :number => "3.0.beta.1",
-    #       :major => 3, :minor => 0, :teeny => -1,
-    #       :prerelease => "beta",
-    #       :prerelease_number => 1
-    #     }
-    #
-    # @return [{Symbol => String/Fixnum}] The version hash
-    def version
-      return @@version if defined?(@@version)
-
-      numbers = File.read(scope('VERSION')).strip.split('.').
-        map {|n| n =~ /^[0-9]+$/ ? n.to_i : n}
-      name = File.read(scope('VERSION_NAME')).strip
-      @@version = {
-        :major => numbers[0],
-        :minor => numbers[1],
-        :teeny => numbers[2],
-        :name => name
-      }
-
-      if numbers[3].is_a?(String)
-        @@version[:teeny] = -1
-        @@version[:prerelease] = numbers[3]
-        @@version[:prerelease_number] = numbers[4]
-      end
-
-      @@version[:number] = numbers.join('.')
-      @@version[:string] = @@version[:number].dup
-
-      if rev = revision_number
-        @@version[:rev] = rev
-        unless rev[0] == ?(
-          @@version[:string] << "." << rev[0...7]
-        end
-      end
-
-      @@version[:string] << " (#{name})"
-      @@version
-    end
-
-    private
-
-    def revision_number
-      if File.exists?(scope('REVISION'))
-        rev = File.read(scope('REVISION')).strip
-        return rev unless rev =~ /^([a-f0-9]+|\(.*\))$/ || rev == '(unknown)'
-      end
-
-      return unless File.exists?(scope('.git/HEAD'))
-      rev = File.read(scope('.git/HEAD')).strip
-      return rev unless rev =~ /^ref: (.*)$/
-
-      ref_name = $1
-      ref_file = scope(".git/#{ref_name}")
-      info_file = scope(".git/info/refs")
-      return File.read(ref_file).strip if File.exists?(ref_file)
-      return unless File.exists?(info_file)
-      File.open(info_file) do |f|
-        f.each do |l|
-          sha, ref = l.strip.split("\t", 2)
-          next unless ref == ref_name
-          return sha
-        end
-      end
-      return nil
-    end
-  end
-
-  extend Sass::Version
-
-  # A string representing the version of Sass.
-  # A more fine-grained representation is available from Sass.version.
-  # @api public
-  VERSION = version[:string] unless defined?(Sass::VERSION)
-end

data/vendor/sass/rails/init.rb

@@ -1 +0,0 @@
-Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/vendor/sass/sass.gemspec

@@ -1,33 +0,0 @@
-require 'rubygems'
-
-# Note that Sass's gem-compilation process requires access to the filesystem.
-# This means that it cannot be automatically run by e.g. GitHub's gem system.
-# However, a build server automatically packages the master branch
-# every time it's pushed to; this is made available as a prerelease gem.
-SASS_GEMSPEC = Gem::Specification.new do |spec|
-  spec.rubyforge_project = 'sass'
-  spec.name = 'sass'
-  spec.summary = "A powerful but elegant CSS compiler that makes CSS fun again."
-  spec.version = File.read(File.dirname(__FILE__) + '/VERSION').strip
-  spec.authors = ['Nathan Weizenbaum', 'Chris Eppstein', 'Hampton Catlin']
-  spec.email = 'sass-lang@googlegroups.com'
-  spec.description = <<-END
-      Sass makes CSS fun again. Sass is an extension of CSS3, adding
-      nested rules, variables, mixins, selector inheritance, and more.
-      It's translated to well-formatted, standard CSS using the
-      command line tool or a web-framework plugin.
-    END
-
-  spec.required_ruby_version = '>= 1.8.7'
-  spec.add_development_dependency 'yard', '>= 0.5.3'
-  spec.add_development_dependency 'maruku', '>= 0.5.9'
-
-  readmes = Dir['*'].reject{ |x| x =~ /(^|[^.a-z])[a-z]+/ || x == "TODO" }
-  spec.executables = ['sass', 'sass-convert', 'scss']
-  spec.files = Dir['rails/init.rb', 'lib/**/*', 'vendor/**/*',
-    'bin/*', 'test/**/*', 'extra/**/*', 'Rakefile', 'init.rb',
-    '.yardopts'] + readmes
-  spec.homepage = 'http://sass-lang.com/'
-  spec.has_rdoc = false
-  spec.test_files = Dir['test/**/*_test.rb']
-end

data/vendor/sass/test/Gemfile

@@ -1,4 +0,0 @@
-source :gemcutter
-
-gem 'rake'
-gem 'less', '< 2.0.0'

data/vendor/sass/test/Gemfile.lock

@@ -1,19 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    less (1.2.21)
-      mutter (>= 0.4.2)
-      treetop (>= 1.4.2)
-    mutter (0.5.3)
-    polyglot (0.3.2)
-    rake (0.9.2)
-    treetop (1.4.10)
-      polyglot
-      polyglot (>= 0.3.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  less (< 2.0.0)
-  rake

data/vendor/sass/test/sass/cache_test.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/test_helper'
-require 'sass/engine'
-
-class CacheTest < Test::Unit::TestCase
-  @@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.exists?("#{@@cache_dir}/asdf/foo.scssc")
-  end
-
-  def test_file_cache_reads_a_file
-    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
-    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exists?("#{@@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.exists?("#{@@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.exists?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
-    assert_nil file_store.retrieve("asdf/foo.scssc", "differentsha1")
-    assert !File.exists?("#{@@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.exists?("#{@@cache_dir}/asdf/foo.scssc")
-    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
-    assert File.exists?("#{@@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.exists?("#{@@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
-
-  class Unmarshalable
-    def _dump(_)
-      raise 'Unmarshalable'
-    end
-  end
-
-  def test_cache_node_with_unmarshalable_option
-    engine = Sass::Engine.new("foo {a: b + c}",
-      :syntax => :scss, :object => Unmarshalable.new, :filename => 'file.scss',
-      :importer => Sass::Importers::Filesystem.new(absolutize('templates')))
-    engine.to_tree
-  end
-
-  private
-  def root_node
-    Sass::Engine.new(<<-SCSS, :syntax => :scss).to_tree
-      @mixin color($c) { color: $c}
-      div { @include color(red); }
-    SCSS
-  end
-end

data/vendor/sass/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 < Test::Unit::TestCase
-  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

data/vendor/sass/test/sass/conversion_test.rb

@@ -1,1199 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../test_helper'
-
-class ConversionTest < Test::Unit::TestCase
-  def test_basic
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz: bang
-  bip: bop
-SASS
-foo bar {
-  baz: bang;
-  bip: bop; }
-SCSS
-    assert_renders <<SASS, <<SCSS, :old => true
-foo bar
-  :baz bang
-  :bip bop
-SASS
-foo bar {
-  baz: bang;
-  bip: bop; }
-SCSS
-  end
-
-  def test_empty_selector
-    assert_renders "foo bar", "foo bar {}"
-  end
-
-  def test_empty_directive
-    assert_scss_to_sass "@media screen", "@media screen {}"
-    assert_scss_to_scss "@media screen {}"
-  end
-
-  def test_empty_control_directive
-    assert_renders "@if false", "@if false {}"
-  end
-
-  def test_nesting
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz bang
-    baz: bang
-    bip: bop
-  blat: boo
-SASS
-foo bar {
-  baz bang {
-    baz: bang;
-    bip: bop; }
-  blat: boo; }
-SCSS
-  end
-
-  def test_nesting_with_parent_ref
-    assert_renders <<SASS, <<SCSS
-foo bar
-  &:hover
-    baz: bang
-SASS
-foo bar {
-  &:hover {
-    baz: bang; } }
-SCSS
-  end
-
-  def test_selector_interpolation
-    assert_renders <<SASS, <<SCSS
-foo \#{$bar + "baz"}.bip
-  baz: bang
-SASS
-foo \#{$bar + "baz"}.bip {
-  baz: bang; }
-SCSS
-  end
-
-  def test_multiline_selector_with_commas
-    assert_renders <<SASS, <<SCSS
-foo bar,
-baz bang
-  baz: bang
-SASS
-foo bar,
-baz bang {
-  baz: bang; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-blat
-  foo bar,
-  baz bang
-    baz: bang
-SASS
-blat {
-  foo bar,
-  baz bang {
-    baz: bang; } }
-SCSS
-  end
-
-  def test_multiline_selector_without_commas
-    assert_scss_to_sass <<SASS, <<SCSS
-foo bar baz bang
-  baz: bang
-SASS
-foo bar
-baz bang {
-  baz: bang; }
-SCSS
-
-    assert_scss_to_scss <<SCSS
-foo bar
-baz bang {
-  baz: bang; }
-SCSS
-  end
-
-  def test_escaped_selector
-    assert_renders <<SASS, <<SCSS
-foo bar
-  \\:hover
-    baz: bang
-SASS
-foo bar {
-  :hover {
-    baz: bang; } }
-SCSS
-  end
-
-  def test_property_name_interpolation
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz\#{$bang}bip\#{$bop}: 12
-SASS
-foo bar {
-  baz\#{$bang}bip\#{$bop}: 12; }
-SCSS
-  end
-
-  def test_property_name_interpolation
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz\#{$bang}bip\#{$bop}: 12
-SASS
-foo bar {
-  baz\#{$bang}bip\#{$bop}: 12; }
-SCSS
-  end
-
-  def test_property_value_interpolation
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz: 12 \#{$bang} bip \#{"bop"} blat
-SASS
-foo bar {
-  baz: 12 \#{$bang} bip \#{"bop"} blat; }
-SCSS
-  end
-
-  def test_dynamic_properties
-    assert_renders <<SASS, <<SCSS
-foo bar
-  baz: 12 $bang "bip"
-SASS
-foo bar {
-  baz: 12 $bang "bip"; }
-SCSS
-  end
-
-  def test_dynamic_properties_with_old
-    assert_renders <<SASS, <<SCSS, :old => true
-foo bar
-  :baz 12 $bang "bip"
-SASS
-foo bar {
-  baz: 12 $bang "bip"; }
-SCSS
-  end
-
-  def test_multiline_properties
-    assert_scss_to_sass <<SASS, <<SCSS
-foo bar
-  baz: bip   bam         boon
-SASS
-foo bar {
-  baz:
-    bip
-  bam
-        boon; }
-SCSS
-
-    assert_scss_to_scss <<OUT, <<IN
-foo bar {
-  baz: bip   bam         boon; }
-OUT
-foo bar {
-  baz:
-    bip
-  bam
-        boon; }
-IN
-  end
-
-  def test_multiline_dynamic_properties
-    assert_scss_to_sass <<SASS, <<SCSS
-foo bar
-  baz: $bip "bam" 12px
-SASS
-foo bar {
-  baz:
-    $bip
-  "bam"
-        12px; }
-SCSS
-
-    assert_scss_to_scss <<OUT, <<IN
-foo bar {
-  baz: $bip "bam" 12px; }
-OUT
-foo bar {
-  baz:
-    $bip
-  "bam"
-        12px; }
-IN
-  end
-
-  def test_silent_comments
-    assert_renders <<SASS, <<SCSS
-// foo
-
-// bar
-
-// baz
-
-foo bar
-  a: b
-SASS
-// foo
-
-// bar
-
-// baz
-
-foo bar {
-  a: b; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-// foo
-// bar
-//   baz
-// bang
-
-foo bar
-  a: b
-SASS
-// foo
-// bar
-//   baz
-// bang
-
-foo bar {
-  a: b; }
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-// foo
-// bar
-//   baz
-// bang
-
-foo bar {
-  a: b; }
-SCSS
-// foo
-// bar
-//   baz
-// bang
-
-foo bar
-  a: b
-SASS
-  end
-
-  def test_nested_silent_comments
-    assert_renders <<SASS, <<SCSS
-foo
-  bar: baz
-  // bip bop
-  // beep boop
-  bang: bizz
-  // bubble bubble
-  // toil trouble
-SASS
-foo {
-  bar: baz;
-  // bip bop
-  // beep boop
-  bang: bizz;
-  // bubble bubble
-  // toil trouble
-}
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  bar: baz;
-  // bip bop
-  // beep boop
-  //   bap blimp
-  bang: bizz;
-  // bubble bubble
-  // toil trouble
-  //    gorp
-}
-SCSS
-foo
-  bar: baz
-  // bip bop
-     beep boop
-       bap blimp
-  bang: bizz
-  // bubble bubble
-    toil trouble
-       gorp
-SASS
-  end
-
-  def test_loud_comments
-    assert_renders <<SASS, <<SCSS
-/* foo
-
-/* bar
-
-/* baz
-
-foo bar
-  a: b
-SASS
-/* foo */
-
-/* bar */
-
-/* baz */
-
-foo bar {
-  a: b; }
-SCSS
-
-    assert_scss_to_sass <<SASS, <<SCSS
-/* foo
- * bar
- *   baz
- * bang
-
-foo bar
-  a: b
-SASS
-/* foo
-   bar
-     baz
-   bang */
-
-foo bar {
-  a: b; }
-SCSS
-
-    assert_scss_to_scss <<SCSS
-/* foo
-   bar
-     baz
-   bang */
-
-foo bar {
-  a: b; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-/* foo
- * bar
- *   baz
- * bang
-
-foo bar
-  a: b
-SASS
-/* foo
- * bar
- *   baz
- * bang */
-
-foo bar {
-  a: b; }
-SCSS
-  end
-
-  def test_nested_loud_comments
-    assert_renders <<SASS, <<SCSS
-foo
-  bar: baz
-  /* bip bop
-   * beep boop
-  bang: bizz
-  /* bubble bubble
-   * toil trouble
-SASS
-foo {
-  bar: baz;
-  /* bip bop
-   * beep boop */
-  bang: bizz;
-  /* bubble bubble
-   * toil trouble */ }
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  bar: baz;
-  /* bip bop
-   * beep boop
-   *   bap blimp */
-  bang: bizz;
-  /* bubble bubble
-   * toil trouble
-   *    gorp */ }
-SCSS
-foo
-  bar: baz
-  /* bip bop
-     beep boop
-       bap blimp
-  bang: bizz
-  /* bubble bubble
-    toil trouble
-       gorp
-SASS
-  end
-
-  def test_loud_comments_with_weird_indentation
-    assert_scss_to_sass <<SASS, <<SCSS
-foo
-  /*      foo
-   * bar
-   *     baz
-  a: b
-SASS
-foo {
-  /* foo
-bar
-    baz */
-  a: b; }
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-foo {
-  /*      foo
-   * bar
-   *     baz */
-  a: b; }
-SCSS
-foo
-  /*      foo
-     bar
-         baz
-  a: b
-SASS
-  end
-
-  def test_immediately_preceding_comments
-    assert_renders <<SASS, <<SCSS
-/* Foo
- * Bar
- * Baz
-.foo#bar
-  a: b
-SASS
-/* Foo
- * Bar
- * Baz */
-.foo#bar {
-  a: b; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-// Foo
-// Bar
-// Baz
-=foo
-  a: b
-SASS
-// Foo
-// Bar
-// Baz
-@mixin foo {
-  a: b; }
-SCSS
-  end
-
-  def test_debug
-    assert_renders <<SASS, <<SCSS
-foo
-  @debug 12px
-  bar: baz
-SASS
-foo {
-  @debug 12px;
-  bar: baz; }
-SCSS
-  end
-
-  def test_directive_without_children
-    assert_renders <<SASS, <<SCSS
-foo
-  @foo #bar "baz"
-  bar: baz
-SASS
-foo {
-  @foo #bar "baz";
-  bar: baz; }
-SCSS
-  end
-
-  def test_directive_with_prop_children
-    assert_renders <<SASS, <<SCSS
-foo
-  @foo #bar "baz"
-    a: b
-    c: d
-
-  bar: baz
-SASS
-foo {
-  @foo #bar "baz" {
-    a: b;
-    c: d; }
-
-  bar: baz; }
-SCSS
-  end
-
-  def test_directive_with_rule_children
-    assert_renders <<SASS, <<SCSS
-foo
-  @foo #bar "baz"
-    #blat
-      a: b
-    .bang
-      c: d
-      e: f
-
-  bar: baz
-SASS
-foo {
-  @foo #bar "baz" {
-    #blat {
-      a: b; }
-    .bang {
-      c: d;
-      e: f; } }
-
-  bar: baz; }
-SCSS
-  end
-
-  def test_directive_with_rule_and_prop_children
-    assert_renders <<SASS, <<SCSS
-foo
-  @foo #bar "baz"
-    g: h
-    #blat
-      a: b
-    .bang
-      c: d
-      e: f
-    i: j
-
-  bar: baz
-SASS
-foo {
-  @foo #bar "baz" {
-    g: h;
-    #blat {
-      a: b; }
-    .bang {
-      c: d;
-      e: f; }
-    i: j; }
-
-  bar: baz; }
-SCSS
-  end
-
-  def test_charset
-    assert_renders <<SASS, <<SCSS
-@charset "utf-8"
-SASS
-@charset "utf-8";
-SCSS
-  end
-
-  def test_for
-    assert_renders <<SASS, <<SCSS
-foo
-  @for $a from $b to $c
-    a: b
-  @for $c from 1 to 16
-    d: e
-    f: g
-SASS
-foo {
-  @for $a from $b to $c {
-    a: b; }
-  @for $c from 1 to 16 {
-    d: e;
-    f: g; } }
-SCSS
-  end
-
-  def test_while
-    assert_renders <<SASS, <<SCSS
-foo
-  @while flaz($a + $b)
-    a: b
-  @while 1
-    d: e
-    f: g
-SASS
-foo {
-  @while flaz($a + $b) {
-    a: b; }
-  @while 1 {
-    d: e;
-    f: g; } }
-SCSS
-  end
-
-  def test_if
-    assert_renders <<SASS, <<SCSS
-foo
-  @if $foo or $bar
-    a: b
-  @if $baz
-    d: e
-  @else if $bang
-    f: g
-  @else
-    h: i
-SASS
-foo {
-  @if $foo or $bar {
-    a: b; }
-  @if $baz {
-    d: e; }
-  @else if $bang {
-    f: g; }
-  @else {
-    h: i; } }
-SCSS
-  end
-
-  def test_each
-    assert_renders <<SASS, <<SCSS
-a
-  @each $number in 1px 2px 3px 4px
-    b: $number
-
-c
-  @each $str in foo, bar, baz, bang
-    d: $str
-SASS
-a {
-  @each $number in 1px 2px 3px 4px {
-    b: $number; } }
-
-c {
-  @each $str in foo, bar, baz, bang {
-    d: $str; } }
-SCSS
-  end
-
-  def test_import
-    assert_renders <<SASS, <<SCSS
-@import foo
-
-@import url(bar.css)
-
-foo
-  bar: baz
-SASS
-@import "foo";
-
-@import url(bar.css);
-
-foo {
-  bar: baz; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-@import foo.css
-
-@import url(bar.css)
-
-foo
-  bar: baz
-SASS
-@import "foo.css";
-
-@import url(bar.css);
-
-foo {
-  bar: baz; }
-SCSS
-  end
-
-  def test_import_as_directive_in_sass
-    assert_equal "@import foo.css\n", to_sass('@import "foo.css"')
-  end
-
-  def test_import_as_directive_in_scss
-    assert_renders <<SASS, <<SCSS
-@import "foo.css" print
-SASS
-@import "foo.css" print;
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-@import url(foo.css) screen, print
-SASS
-@import url(foo.css) screen, print;
-SCSS
-  end
-
-  def test_adjacent_imports
-    assert_renders <<SASS, <<SCSS
-@import foo.sass
-@import bar.scss
-@import baz
-SASS
-@import "foo.sass";
-@import "bar.scss";
-@import "baz";
-SCSS
-  end
-
-  def test_non_adjacent_imports
-    assert_renders <<SASS, <<SCSS
-@import foo.sass
-
-@import bar.scss
-
-@import baz
-SASS
-@import "foo.sass";
-
-@import "bar.scss";
-
-@import "baz";
-SCSS
-  end
-
-  def test_extend
-    assert_renders <<SASS, <<SCSS
-.foo
-  @extend .bar
-  @extend .baz:bang
-SASS
-.foo {
-  @extend .bar;
-  @extend .baz:bang; }
-SCSS
-  end
-
-  def test_argless_mixin_definition
-    assert_renders <<SASS, <<SCSS
-=foo-bar
-  baz
-    a: b
-SASS
-@mixin foo-bar {
-  baz {
-    a: b; } }
-SCSS
-
-    assert_scss_to_sass <<SASS, <<SCSS
-=foo-bar
-  baz
-    a: b
-SASS
-@mixin foo-bar() {
-  baz {
-    a: b; } }
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-@mixin foo-bar {
-  baz {
-    a: b; } }
-SCSS
-=foo-bar()
-  baz
-    a: b
-SASS
-  end
-
-  def test_mixin_definition_without_defaults
-    assert_renders <<SASS, <<SCSS
-=foo-bar($baz, $bang)
-  baz
-    a: $baz $bang
-SASS
-@mixin foo-bar($baz, $bang) {
-  baz {
-    a: $baz $bang; } }
-SCSS
-  end
-
-  def test_mixin_definition_with_defaults
-    assert_renders <<SASS, <<SCSS
-=foo-bar($baz, $bang: 12px)
-  baz
-    a: $baz $bang
-SASS
-@mixin foo-bar($baz, $bang: 12px) {
-  baz {
-    a: $baz $bang; } }
-SCSS
-
-    assert_sass_to_scss <<SCSS, <<SASS
-@mixin foo-bar($baz, $bang: foo) {
-  baz {
-    a: $baz $bang; } }
-SCSS
-=foo-bar($baz, $bang: foo)
-  baz
-    a: $baz $bang
-SASS
-  end
-
-  def test_argless_mixin_include
-    assert_renders <<SASS, <<SCSS
-foo
-  +foo-bar
-  a: blip
-SASS
-foo {
-  @include foo-bar;
-  a: blip; }
-SCSS
-  end
-
-  def test_mixin_include
-    assert_renders <<SASS, <<SCSS
-foo
-  +foo-bar(12px, "blaz")
-  a: blip
-SASS
-foo {
-  @include foo-bar(12px, "blaz");
-  a: blip; }
-SCSS
-  end
-
-  def test_mixin_include_with_keyword_args
-    assert_renders <<SASS, <<SCSS
-foo
-  +foo-bar(12px, "blaz", $blip: blap, $bloop: blop)
-  +foo-bar($blip: blap, $bloop: blop)
-  a: blip
-SASS
-foo {
-  @include foo-bar(12px, "blaz", $blip: blap, $bloop: blop);
-  @include foo-bar($blip: blap, $bloop: blop);
-  a: blip; }
-SCSS
-  end
-
-  def test_argless_function_definition
-    assert_renders <<SASS, <<SCSS
-@function foo()
-  $var: 1 + 1
-  @return $var
-SASS
-@function foo() {
-  $var: 1 + 1;
-  @return $var; }
-SCSS
-  end
-
-  def test_function_definition_without_defaults
-    assert_renders <<SASS, <<SCSS
-@function foo($var1, $var2)
-  @if $var1
-    @return $var1 + $var2
-SASS
-@function foo($var1, $var2) {
-  @if $var1 {
-    @return $var1 + $var2; } }
-SCSS
-  end
-
-  def test_function_definition_with_defaults
-    assert_renders <<SASS, <<SCSS
-@function foo($var1, $var2: foo)
-  @if $var1
-    @return $var1 + $var2
-SASS
-@function foo($var1, $var2: foo) {
-  @if $var1 {
-    @return $var1 + $var2; } }
-SCSS
-  end
-
-  def test_variable_definition
-    assert_renders <<SASS, <<SCSS
-$var1: 12px + 15px
-
-foo
-  $var2: flaz(#abcdef)
-  val: $var1 $var2
-SASS
-$var1: 12px + 15px;
-
-foo {
-  $var2: flaz(#abcdef);
-  val: $var1 $var2; }
-SCSS
-  end
-
-  def test_guarded_variable_definition
-    assert_renders <<SASS, <<SCSS
-$var1: 12px + 15px !default
-
-foo
-  $var2: flaz(#abcdef) !default
-  val: $var1 $var2
-SASS
-$var1: 12px + 15px !default;
-
-foo {
-  $var2: flaz(#abcdef) !default;
-  val: $var1 $var2; }
-SCSS
-  end
-
-  def test_multiple_variable_definitions
-    assert_renders <<SASS, <<SCSS
-$var1: foo
-$var2: bar
-$var3: baz
-
-$var4: bip
-$var5: bap
-SASS
-$var1: foo;
-$var2: bar;
-$var3: baz;
-
-$var4: bip;
-$var5: bap;
-SCSS
-  end
-
-  def test_division_asserted_with_parens
-    assert_renders <<SASS, <<SCSS
-foo
-  a: (1px / 2px)
-SASS
-foo {
-  a: (1px / 2px); }
-SCSS
-  end
-
-  def test_division_not_asserted_when_unnecessary
-    assert_renders <<SASS, <<SCSS
-$var: 1px / 2px
-
-foo
-  a: $var
-SASS
-$var: 1px / 2px;
-
-foo {
-  a: $var; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-$var: 1px
-
-foo
-  a: $var / 2px
-SASS
-$var: 1px;
-
-foo {
-  a: $var / 2px; }
-SCSS
-
-    assert_renders <<SASS, <<SCSS
-foo
-  a: 1 + 1px / 2px
-SASS
-foo {
-  a: 1 + 1px / 2px; }
-SCSS
-  end
-
-  def test_literal_slash
-    assert_renders <<SASS, <<SCSS
-foo
-  a: 1px / 2px
-SASS
-foo {
-  a: 1px / 2px; }
-SCSS
-  end
-
-  # Hacks
-
-  def test_declaration_hacks
-    assert_renders <<SASS, <<SCSS
-foo
-  _name: val
-  *name: val
-  #name: val
-  .name: val
-  name/**/: val
-  name/*\\**/: val
-  name: val
-SASS
-foo {
-  _name: val;
-  *name: val;
-  #name: val;
-  .name: val;
-  name/**/: val;
-  name/*\\**/: val;
-  name: val; }
-SCSS
-  end
-
-  def test_old_declaration_hacks
-    assert_renders <<SASS, <<SCSS, :old => true
-foo
-  :_name val
-  :*name val
-  :#name val
-  :.name val
-  :name val
-SASS
-foo {
-  _name: val;
-  *name: val;
-  #name: val;
-  .name: val;
-  name: val; }
-SCSS
-  end
-
-  def test_selector_hacks
-    assert_selector_renders = lambda do |s|
-      assert_renders <<SASS, <<SCSS
-#{s}
-  a: b
-SASS
-#{s} {
-  a: b; }
-SCSS
-    end
-
-    assert_selector_renders['> E']
-    assert_selector_renders['+ E']
-    assert_selector_renders['~ E']
-    assert_selector_renders['> > E']
-
-    assert_selector_renders['E*']
-    assert_selector_renders['E*.foo']
-    assert_selector_renders['E*:hover']
-  end
-
-  def test_disallowed_colon_hack
-    assert_raise_message(Sass::SyntaxError, 'The ":name: val" hack is not allowed in the Sass indented syntax') do
-      to_sass("foo {:name: val;}", :syntax => :scss)
-    end
-  end
-
-  def test_nested_properties
-    assert_renders <<SASS, <<SCSS
-div
-  before: before
-  background:
-    color: blue
-    repeat: no-repeat
-  after: after
-SASS
-div {
-  before: before;
-  background: {
-    color: blue;
-    repeat: no-repeat; };
-  after: after; }
-
-SCSS
-  end
-
-  def test_dasherize
-    assert_sass_to_scss(<<SCSS, <<SASS, :dasherize => true)
-@mixin under-scored-mixin($under-scored-arg: $under-scored-default) {
-  bar: $under-scored-arg; }
-
-div {
-  foo: under-scored-fn($under-scored-var + "before\#{$another-under-scored-var}after");
-  @include under-scored-mixin($passed-arg);
-  selector-\#{$under-scored-interp}: bold; }
-
-@if $under-scored {
-  @for $for-var from $from-var to $to-var {
-    @while $while-var == true {
-      $while-var: false; } } }
-SCSS
-=under_scored_mixin($under_scored_arg: $under_scored_default)
-  bar: $under_scored_arg
-div
-  foo: under_scored_fn($under_scored_var + "before\#{$another_under_scored_var}after")
-  +under_scored_mixin($passed_arg)
-  selector-\#{$under_scored_interp}: bold
-@if $under_scored
-  @for $for_var from $from_var to $to_var
-    @while $while_var == true
-      $while_var : false
-SASS
-  end
-
-   def test_loud_comment_conversion
-    assert_renders(<<SASS, <<SCSS)
-/*! \#{"interpolated"}
-SASS
-/*! \#{"interpolated"} */
-SCSS
-    silence_warnings {assert_renders(<<SASS, <<SCSS)}
-//! \#{"interpolated"}
-//!
-//! \#{"also interpolated"}
-SASS
-//! \#{"interpolated"}
-//!
-//! \#{"also interpolated"}
-SCSS
-  end
-
-  private
-
-  def assert_sass_to_sass(sass, options = {})
-    assert_equal(sass.rstrip, to_sass(sass, options).rstrip,
-      "Expected Sass to transform to itself")
-  end
-
-  def assert_scss_to_sass(sass, scss, options = {})
-    assert_equal(sass.rstrip, to_sass(scss, options.merge(:syntax => :scss)).rstrip,
-      "Expected SCSS to transform to Sass")
-  end
-
-  def assert_scss_to_scss(scss, in_scss = nil, options = nil)
-    if in_scss.is_a?(Hash)
-      options = in_scss
-      in_scss = nil
-    end
-
-    in_scss ||= scss
-    options ||= {}
-
-    assert_equal(scss.rstrip, to_scss(in_scss, options.merge(:syntax => :scss)).rstrip,
-      "Expected SCSS to transform to #{scss == in_scss ? 'itself' : 'SCSS'}k")
-  end
-
-  def assert_sass_to_scss(scss, sass, options = {})
-    assert_equal(scss.rstrip, to_scss(sass, options).rstrip,
-      "Expected Sass to transform to SCSS")
-  end
-
-  def assert_renders(sass, scss, options = {})
-    assert_sass_to_sass(sass, options)
-    assert_scss_to_sass(sass, scss, options)
-    assert_scss_to_scss(scss, options)
-    assert_sass_to_scss(scss, sass, options)
-  end
-
-  def to_sass(scss, options = {})
-    Sass::Util.silence_sass_warnings do
-      Sass::Engine.new(scss, options).to_tree.to_sass(options)
-    end
-  end
-
-  def to_scss(sass, options = {})
-    Sass::Util.silence_sass_warnings do
-      Sass::Engine.new(sass, options).to_tree.to_scss(options)
-    end
-  end
-end