haml 3.0.6 → 3.0.7

data/VERSION

@@ -1 +1 @@
-3.0.6
+3.0.7

data/lib/haml/engine.rb

@@ -85,8 +85,15 @@ module Haml
         :format => :xhtml,
         :escape_html => false,
       }
+
+
+      template = check_haml_encoding(template) do |msg, line|
+        raise Haml::Error.new(msg, line)
+      end
+
       unless ruby1_8?
-        @options[:encoding] = Encoding.default_internal || "utf-8"
+        @options[:encoding] = Encoding.default_internal || template.encoding
+        @options[:encoding] = "utf-8" if @options[:encoding].name == "US-ASCII"
       end
       @options.merge! options.reject {|k, v| v.nil?}
       @index = 0
@@ -99,8 +106,6 @@ module Haml
         @options[:encoding] = @options[:encoding].name
       end
 
-      template = check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
-
       # :eod is a special end-of-document marker
       @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
       @template_index = 0

data/lib/haml/exec.rb

@@ -323,6 +323,12 @@ END
         opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
           @options[:for_engine][:cache] = false
         end
+
+        unless ::Haml::Util.ruby1_8?
+          opts.on('-E encoding', 'Specify the default encoding for Sass files.') do |encoding|
+            Encoding.default_external = encoding
+          end
+        end
       end
 
       # Processes the options set by the command-line arguments,
@@ -474,6 +480,14 @@ MSG
           @options[:load_paths] << path
         end
 
+        unless ::Haml::Util.ruby1_8?
+          opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+            external, internal = encoding.split(':')
+            Encoding.default_external = external if external && !external.empty?
+            Encoding.default_internal = internal if internal && !internal.empty?
+          end
+        end
+
         opts.on('--debug', "Print out the precompiled Ruby source.") do
           @options[:debug] = true
         end
@@ -656,6 +670,12 @@ END
           @options[:for_engine][:read_cache] = false
         end
 
+        unless ::Haml::Util.ruby1_8?
+          opts.on('-E encoding', 'Specify the default encoding for Sass and CSS files.') do |encoding|
+            Encoding.default_external = encoding
+          end
+        end
+
         super
       end
 

data/lib/haml/html.rb

@@ -285,7 +285,7 @@ module Haml
                self.previous.content =~ /\A\s*\Z/ && self.previous.previous.nil?)
             nuke_outer_whitespace = true
           else
-            output << "- succeed #{self.next.content.slice!(/\A[^\s]+/).dump} do\n"
+            output << "= succeed #{self.next.content.slice!(/\A[^\s]+/).dump} do\n"
             tabs += 1
             output << tabulate(tabs)
           end

data/lib/haml/template.rb

@@ -43,7 +43,11 @@ module Haml
 end
 
 unless Haml::Util.rails_env == "development"
-  Haml::Template.options[:ugly] = true
+  Haml::Template.options[:ugly] ||= true
+end
+
+if ActionPack::VERSION::MAJOR >= 3
+  Haml::Template.options[:format] ||= :html5
 end
 
 # Decide how we want to load Haml into Rails.

data/lib/haml/template/plugin.rb

@@ -11,6 +11,8 @@ module Haml
       include Haml::Util.av_template_class(:Handlers)::Compilable
     end
 
+    def handles_encoding?; true; end
+
     def compile(template)
       options = Haml::Template.options.dup
 

data/lib/haml/util.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'set'
 require 'enumerator'
 require 'stringio'
+require 'strscan'
 require 'haml/root'
 require 'haml/util/subset_map'
 
@@ -127,9 +128,13 @@ module Haml
     # @param enum [Enumerable]
     # @return [Array] The enumerable with strings merged
     def merge_adjacent_strings(enum)
-      e = enum.inject([]) do |a, e|
-        if e.is_a?(String) && a.last.is_a?(String)
-          a.last << e
+      enum.inject([]) do |a, e|
+        if e.is_a?(String)
+          if a.last.is_a?(String)
+            a.last << e
+          else
+            a << e.dup
+          end
         else
           a << e
         end
@@ -434,6 +439,109 @@ MSG
       return str
     end
 
+    # Like {\#check\_encoding}, but also checks for a Ruby-style `-# coding:` comment
+    # at the beginning of the template and uses that encoding if it exists.
+    #
+    # The Sass encoding rules are simple.
+    # If a `-# coding:` comment exists,
+    # we assume that that's the original encoding of the document.
+    # Otherwise, we use whatever encoding Ruby has.
+    #
+    # Haml uses the same rules for parsing coding comments as Ruby.
+    # This means that it can understand Emacs-style comments
+    # (e.g. `-*- encoding: "utf-8" -*-`),
+    # and also that it cannot understand non-ASCII-compatible encodings
+    # such as `UTF-16` and `UTF-32`.
+    #
+    # @param str [String] The Haml template of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
+    # @return [String] The original string encoded properly
+    # @raise [ArgumentError] if the document declares an unknown encoding
+    def check_haml_encoding(str, &block)
+      return check_encoding(str, &block) if ruby1_8?
+
+      bom, encoding = parse_haml_magic_comment(str)
+      if encoding; str.force_encoding(encoding)
+      elsif bom; str.force_encoding("UTF-8")
+      end
+
+      return check_encoding(str, &block)
+    end
+
+    # Like {\#check\_encoding}, but also checks for a `@charset` declaration
+    # at the beginning of the file and uses that encoding if it exists.
+    #
+    # The Sass encoding rules are simple.
+    # If a `@charset` declaration exists,
+    # we assume that that's the original encoding of the document.
+    # Otherwise, we use whatever encoding Ruby has.
+    # Then we convert that to UTF-8 to process internally.
+    # The UTF-8 end result is what's returned by this method.
+    #
+    # @param str [String] The string of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
+    # @return [(String, Encoding)] The original string encoded as UTF-8,
+    #   and the source encoding of the string (or `nil` under Ruby 1.8)
+    # @raise [Encoding::UndefinedConversionError] if the source encoding
+    #   cannot be converted to UTF-8
+    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
+    def check_sass_encoding(str, &block)
+      return check_encoding(str, &block), nil if ruby1_8?
+      # We allow any printable ASCII characters but double quotes in the charset decl
+      bin = str.dup.force_encoding("BINARY")
+      encoding = Haml::Util::ENCODINGS_TO_CHECK.find do |enc|
+        bin =~ Haml::Util::CHARSET_REGEXPS[enc]
+      end
+      charset, bom = $1, $2
+      if charset
+        charset = charset.force_encoding(encoding).encode("UTF-8")
+        if endianness = encoding[/[BL]E$/]
+          begin
+            Encoding.find(charset + endianness)
+            charset << endianness
+          rescue ArgumentError # Encoding charset + endianness doesn't exist
+          end
+        end
+        str.force_encoding(charset)
+      elsif bom
+        str.force_encoding(encoding)
+      end
+
+      str = check_encoding(str, &block)
+      return str.encode("UTF-8"), str.encoding
+    end
+
+    unless ruby1_8?
+      # @private
+      def _enc(string, encoding)
+        string.encode(encoding).force_encoding("BINARY")
+      end
+
+      # We could automatically add in any non-ASCII-compatible encodings here,
+      # but there's not really a good way to do that
+      # without manually checking that each encoding
+      # encodes all ASCII characters properly,
+      # which takes long enough to affect the startup time of the CLI.
+      ENCODINGS_TO_CHECK = %w[UTF-8 UTF-16BE UTF-16LE UTF-32BE UTF-32LE]
+
+      CHARSET_REGEXPS = Hash.new do |h, e|
+        h[e] =
+          begin
+            # /\A(?:\uFEFF)?@charset "(.*?)"|\A(\uFEFF)/
+            Regexp.new(/\A(?:#{_enc("\uFEFF", e)})?#{
+              _enc('@charset "', e)}(.*?)#{_enc('"', e)}|\A(#{
+              _enc("\uFEFF", e)})/)
+          rescue
+            # /\A@charset "(.*?)"/
+            Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
+          end
+      end
+    end
+
     # Checks to see if a class has a given method.
     # For example:
     #
@@ -623,5 +731,36 @@ METHOD
       return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
       return lcs_backtrace(c, x, y, i-1, j, &block)
     end
+
+    # Parses a magic comment at the beginning of a Haml file.
+    # The parsing rules are basically the same as Ruby's.
+    #
+    # @return [(Boolean, String or nil)]
+    #   Whether the document begins with a UTF-8 BOM,
+    #   and the declared encoding of the document (or nil if none is declared)
+    def parse_haml_magic_comment(str)
+      scanner = StringScanner.new(str.dup.force_encoding("BINARY"))
+      bom = scanner.scan(/\xEF\xBB\xBF/n)
+      return bom unless scanner.scan(/-\s*#\s*/n)
+      if coding = try_parse_haml_emacs_magic_comment(scanner)
+        return bom, coding
+      end
+
+      return bom unless scanner.scan(/.*?coding[=:]\s*([\w-]+)/in)
+      return bom, scanner[1]
+    end
+
+    def try_parse_haml_emacs_magic_comment(scanner)
+      pos = scanner.pos
+      return unless scanner.scan(/.*?-\*-\s*/n)
+      # From Ruby's parse.y
+      return unless scanner.scan(/([^\s'":;]+)\s*:\s*("(?:\\.|[^"])*"|[^"\s;]+?)[\s;]*-\*-/n)
+      name, val = scanner[1], scanner[2]
+      return unless name =~ /(en)?coding/in
+      val = $1 if val =~ /^"(.*)"$/n
+      return val
+    ensure
+      scanner.pos = pos
+    end
   end
 end

data/lib/sass/css.rb

@@ -14,7 +14,12 @@ module Sass
   #     Sass::CSS.new("p { color: blue }").render(:sass) #=> "p\n  color: blue"
   #     Sass::CSS.new("p { color: blue }").render(:scss) #=> "p {\n  color: blue; }"
   class CSS
-    # @param template [String] The CSS code
+    # @param template [String] The CSS stylesheet.
+    #   This stylesheet can be encoded using any encoding
+    #   that can be converted to Unicode.
+    #   If the stylesheet contains an `@charset` declaration,
+    #   that overrides the Ruby encoding
+    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
     # @option options :old [Boolean] (false)
     #     Whether or not to output old property syntax
     #     (`:color blue` as opposed to `color: blue`).
@@ -37,18 +42,35 @@ module Sass
     # @return [String] The resulting Sass or SCSS code
     # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
     def render(fmt = :sass)
-      Haml::Util.check_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
-
+      check_encoding!
       build_tree.send("to_#{fmt}", @options).strip + "\n"
     rescue Sass::SyntaxError => err
       err.modify_backtrace(:filename => @options[:filename] || '(css)')
       raise err
     end
 
+    # Returns the original encoding of the document,
+    # or `nil` under Ruby 1.8.
+    #
+    # @return [Encoding, nil]
+    # @raise [Encoding::UndefinedConversionError] if the source encoding
+    #   cannot be converted to UTF-8
+    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
+    def source_encoding
+      check_encoding!
+      @original_encoding
+    end
+
     private
 
+    def check_encoding!
+      return if @checked_encoding
+      @checked_encoding = true
+      @template, @original_encoding = Haml::Util.check_sass_encoding(@template) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
+      end
+    end
+
     # Parses the CSS template and applies various transformations
     #
     # @return [Tree::Node] The root node of the parsed tree

data/lib/sass/engine.rb

@@ -133,6 +133,11 @@ module Sass
     }.freeze
 
     # @param template [String] The Sass template.
+    #   This template can be encoded using any encoding
+    #   that can be converted to Unicode.
+    #   If the template contains an `@charset` declaration,
+    #   that overrides the Ruby encoding
+    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
     # @param options [{Symbol => Object}] An options hash;
     #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
     def initialize(template, options={})
@@ -155,9 +160,12 @@ module Sass
     #
     # @return [String] The CSS
     # @raise [Sass::SyntaxError] if there's an error in the document
+    # @raise [Encoding::UndefinedConversionError] if the source encoding
+    #   cannot be converted to UTF-8
+    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def render
-      return _to_tree.render unless @options[:quiet]
-      Haml::Util.silence_haml_warnings {_to_tree.render}
+      return _render unless @options[:quiet]
+      Haml::Util.silence_haml_warnings {_render}
     end
     alias_method :to_css, :render
 
@@ -170,10 +178,28 @@ module Sass
       Haml::Util.silence_haml_warnings {_to_tree}
     end
 
+    # Returns the original encoding of the document,
+    # or `nil` under Ruby 1.8.
+    #
+    # @return [Encoding, nil]
+    # @raise [Encoding::UndefinedConversionError] if the source encoding
+    #   cannot be converted to UTF-8
+    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
+    def source_encoding
+      check_encoding!
+      @original_encoding
+    end
+
     private
 
+    def _render
+      rendered = _to_tree.render
+      return rendered if ruby1_8?
+      return rendered.encode(source_encoding)
+    end
+
     def _to_tree
-      @template = check_encoding(@template) {|msg, line| raise Sass::SyntaxError.new(msg, :line => line)}
+      check_encoding!
 
       if @options[:syntax] == :scss
         root = Sass::SCSS::Parser.new(@template).parse
@@ -190,6 +216,14 @@ module Sass
       raise e
     end
 
+    def check_encoding!
+      return if @checked_encoding
+      @checked_encoding = true
+      @template, @original_encoding = check_sass_encoding(@template) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
+      end
+    end
+
     def tabulate(string)
       tab_str = nil
       comment_tab_str = nil
@@ -603,8 +637,7 @@ WARNING
       end
 
       return silent ? "//" : "/* */" if content.empty?
-      content.each {|l| l.gsub!(/^\* /, '')}
-      content.map! {|l| (l.empty? ? "" : " ") + l}
+      content.map! {|l| l.gsub!(/^\*( ?)/, '\1') || (l.empty? ? "" : " ") + l}
       content.first.gsub!(/^ /, '') unless removed_first
       content.last.gsub!(%r{ ?\*/ *$}, '')
       if silent

data/lib/sass/files.rb

@@ -17,7 +17,9 @@ module Sass
     # @raise [Sass::SyntaxError] if there's an error in the document.
     #   The caller has responsibility for setting backtrace information, if necessary
     def tree_for(filename, options)
-      options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
+      default_options = Sass::Engine::DEFAULT_OPTIONS.dup
+      default_options.delete(:syntax)
+      options = default_options.merge!(options)
       text = File.read(filename)
 
       if options[:cache] || options[:read_cache]
@@ -32,9 +34,9 @@ module Sass
 
       options = options.merge(:filename => filename)
       if filename =~ /\.scss$/
-        options = options.merge(:syntax => :scss)
+        options = {:syntax => :scss}.merge(options)
       elsif filename =~ /\.sass$/
-        options = options.merge(:syntax => :sass)
+        options = {:syntax => :sass}.merge(options)
       end
 
       engine = Sass::Engine.new(text, options)

data/lib/sass/script/parser.rb

@@ -186,7 +186,7 @@ RUBY
       production :equals, :interpolation, :single_eq
 
       def try_op_before_interp(op, prev = nil)
-        return unless @lexer.peek.type == :begin_interpolation
+        return unless @lexer.peek && @lexer.peek.type == :begin_interpolation
         wb = @lexer.whitespace?(op)
         str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
         str.line = @lexer.line

data/lib/sass/scss/parser.rb

@@ -6,7 +6,9 @@ module Sass
     # The parser for SCSS.
     # It parses a string of code into a tree of {Sass::Tree::Node}s.
     class Parser
-      # @param str [String, StringScanner] The source document to parse
+      # @param str [String, StringScanner] The source document to parse.
+      #   Note that `Parser` *won't* raise a nice error message if this isn't properly parsed;
+      #   for that, you should use the higher-level {Sass::Engine} or {Sass::CSS}.
       # @param line [Fixnum] The line on which the source string appeared,
       #   if it's part of another document
       def initialize(str, line = 1)
@@ -46,10 +48,7 @@ module Sass
           if @template.is_a?(StringScanner)
             @template
           else
-            StringScanner.new(
-              Haml::Util.check_encoding(@template) do |msg, line|
-                raise Sass::SyntaxError.new(msg, :line => line)
-              end.gsub("\r", ""))
+            StringScanner.new(@template.gsub("\r", ""))
           end
       end
 

data/lib/sass/tree/import_node.rb

@@ -70,7 +70,9 @@ module Sass
       #   variable and mixin values
       def perform!(environment)
         environment.push_frame(:filename => @filename, :line => @line)
-        root = Sass::Files.tree_for(full_filename, @options)
+        options = @options.dup
+        options.delete(:syntax)
+        root = Sass::Files.tree_for(full_filename, options)
         @template = root.template
         self.children = root.children
         self.children = perform_children(environment)

data/lib/sass/tree/rule_node.rb

@@ -53,8 +53,11 @@ module Sass::Tree
     # @param rule [Array<String, Sass::Script::Node>]
     #   The CSS rule. See \{#rule}
     def initialize(rule)
-      @rule = Haml::Util.strip_string_array(
-        Haml::Util.merge_adjacent_strings(rule))
+      #p rule
+      merged = Haml::Util.merge_adjacent_strings(rule)
+      #p merged
+      @rule = Haml::Util.strip_string_array(merged)
+      #p @rule
       @tabs = 0
       super()
     end

data/test/haml/engine_test.rb

@@ -1546,7 +1546,6 @@ HAML
   unless Haml::Util.ruby1_8?
     def test_default_encoding
       assert_equal(Encoding.find("utf-8"), render(<<HAML.encode("us-ascii")).encoding)
-HTML
 %p bar
 %p foo
 HAML
@@ -1605,6 +1604,202 @@ HAML
       assert_equal(3, e.line)
       assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
     end
+
+    def test_same_coding_comment_as_encoding
+      assert_renders_encoded(<<HTML, <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: utf-8
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_different_coding_comment_than_encoding
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_different_coding_than_system
+      assert_renders_encoded(<<HTML.encode("IBM866"), <<HAML.encode("IBM866"))
+<p>тАЬ</p>
+HTML
+%p тАЬ
+HAML
+    end
+
+    def test_case_insensitive_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# CodINg: IbM866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_whitespace_insensitive_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-#coding:ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_equals_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# CodINg= ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_prefixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# foo BAR FAOJcoding: ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_suffixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866 ASFJ (&(&#!$
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_prefixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_suffixed_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# coding: ibm866 -*- coding: blah
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_emacs_encoding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- encoding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_quoted_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: "ibm866" -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_whitespace_insensitive_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-#-*-coding:ibm866-*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_whitespace_insensitive_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-#-*-coding:ibm866-*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_one_of_several_emacs_comments
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- foo: bar; coding: ibm866; baz: bang -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_prefixed_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# foo bar coding: baz -*- coding: ibm866 -*-
+%p bâr
+%p föö
+HAML
+    end
+
+    def test_suffixed_emacs_coding_comment
+      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
+<p>bâr</p>
+<p>föö</p>
+HTML
+-# -*- coding: ibm866 -*- foo bar coding: baz
+%p bâr
+%p föö
+HAML
+    end
+
   end
 
   private
@@ -1619,4 +1814,10 @@ HAML
 <p>föö</p>
 HTML
   end
+
+  def assert_renders_encoded(html, haml)
+    result = render(haml)
+    assert_equal html.encoding, result.encoding
+    assert_equal html, result
+  end
 end

data/test/haml/html2haml_test.rb

@@ -268,7 +268,7 @@ HTML
     assert_equal(<<HAML.rstrip, render(<<HTML))
 #foo
   Batch
-  - succeed "," do
+  = succeed "," do
     %span Foo
   %span Bar
 HAML

data/test/haml/util_test.rb

@@ -64,6 +64,9 @@ class UtilTest < Test::Unit::TestCase
   def test_merge_adjacent_strings
     assert_equal(["foo bar baz", :bang, "biz bop", 12],
       merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))
+    str = "foo"
+    assert_equal(["foo foo foo", :bang, "foo foo", 12],
+      merge_adjacent_strings([str, " ", str, " ", str, :bang, str, " ", str, 12]))
   end
 
   def test_intersperse

data/test/sass/engine_test.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/engine'
 require 'stringio'
@@ -1422,6 +1423,18 @@ CSS
 SASS
   end
 
+  def test_loud_comments_with_no_space_after_starred_lines
+    assert_equal(<<CSS, render(<<SASS))
+/*bip bop
+ *beep boop
+ *bap blimp */
+CSS
+/*bip bop
+ *beep boop
+ *bap blimp
+SASS
+  end
+
   def test_comment_indentation_at_beginning_of_doc
     assert_equal <<CSS, render(<<SASS)
 /* foo
@@ -2038,6 +2051,94 @@ SASS
       assert_equal(3, e.sass_line)
       assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
     end
+
+    def test_same_charset_as_encoding
+      assert_renders_encoded(<<CSS, <<SASS)
+@charset "utf-8";
+fóó {
+  a: b; }
+CSS
+@charset "utf-8"
+fóó
+  a: b
+SASS
+    end
+
+    def test_different_charset_than_encoding
+      assert_renders_encoded(<<CSS.force_encoding("IBM866"), <<SASS)
+@charset "ibm866";
+fóó {
+  a: b; }
+CSS
+@charset "ibm866"
+fóó
+  a: b
+SASS
+    end
+
+    def test_different_encoding_than_system
+      assert_renders_encoded(<<CSS.encode("IBM866"), <<SASS.encode("IBM866"))
+тАЬ {
+  a: b; }
+CSS
+тАЬ
+  a: b
+SASS
+    end
+
+    def test_multibyte_charset
+      assert_renders_encoded(<<CSS.encode("UTF-16BE"), <<SASS.encode("UTF-16BE").force_encoding("UTF-8"))
+@charset "utf-16be";
+fóó {
+  a: b; }
+CSS
+@charset "utf-16be"
+fóó
+  a: b
+SASS
+    end
+
+    def test_multibyte_charset_without_endian_specifier
+      assert_renders_encoded(<<CSS.encode("UTF-32LE"), <<SASS.encode("UTF-32LE").force_encoding("UTF-8"))
+@charset "utf-32";
+fóó {
+  a: b; }
+CSS
+@charset "utf-32"
+fóó
+  a: b
+SASS
+    end
+
+    def test_utf8_bom
+      assert_renders_encoded(<<CSS, <<SASS.force_encoding("BINARY"))
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
+
+    def test_utf16le_bom
+      assert_renders_encoded(<<CSS.encode("UTF-16LE"), <<SASS.encode("UTF-16LE").force_encoding("BINARY"))
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
+
+    def test_utf32be_bom
+      assert_renders_encoded(<<CSS.encode("UTF-32BE"), <<SASS.encode("UTF-32BE").force_encoding("BINARY"))
+fóó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+SASS
+    end
   end
 
   private
@@ -2046,6 +2147,12 @@ SASS
     expected.each {|k, v| assert_equal(v, hash[k])}
   end
 
+  def assert_renders_encoded(css, sass)
+    result = render(sass)
+    assert_equal css.encoding, result.encoding
+    assert_equal css, result
+  end
+
   def render(sass, options = {})
     munge_filename options
     Sass::Engine.new(sass, options).render

data/test/sass/scss/scss_test.rb

@@ -979,6 +979,16 @@ foo {
 SCSS
   end
 
+  def test_interpolation_with_bracket_on_next_line
+    assert_equal <<CSS, render(<<SCSS)
+a.foo b {
+  color: red; }
+CSS
+a.\#{"foo"} b
+{color: red}
+SCSS
+  end
+
   def test_extra_comma_in_mixin_arglist_error
     assert_raise(Sass::SyntaxError, <<MESSAGE) {render <<SCSS}
 Invalid CSS after "@include foo(bar, ": expected mixin argument, was ")"

data/test/test_helper.rb

@@ -9,6 +9,7 @@ require 'sass'
 
 require 'haml/template'
 Haml::Template.options[:ugly] = false
+Haml::Template.options[:format] = :xhtml
 
 Sass::RAILS_LOADED = true unless defined?(Sass::RAILS_LOADED)
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 0
-  - 6
-  version: 3.0.6
+  - 7
+  version: 3.0.7
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-24 00:00:00 -07:00
+date: 2010-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency