haml 3.0.22 → 3.0.23

data/VERSION

@@ -1 +1 @@
-3.0.22
+3.0.23

data/lib/haml/exec.rb

@@ -155,7 +155,7 @@ module Haml
       end
 
       def handle_load_error(err)
-        dep = err.message.scan(/^no such file to load -- (.*)/)[0]
+        dep = err.message[/^no such file to load -- (.*)/, 1]
         raise err if @options[:trace] || dep.nil? || dep.empty?
         $stderr.puts <<MESSAGE
 Required dependency #{dep} not found!

data/lib/haml/precompiler.rb

@@ -118,8 +118,8 @@ END
 
       names.map do |name|
         # Can't use || because someone might explicitly pass in false with a symbol
-        sym_local = "_haml_locals[#{inspect(name.to_sym)}]"
-        str_local = "_haml_locals[#{inspect(name.to_s)}]"
+        sym_local = "_haml_locals[#{inspect_obj(name.to_sym)}]"
+        str_local = "_haml_locals[#{inspect_obj(name.to_s)}]"
         "#{name} = #{sym_local}.nil? ? #{str_local} : #{sym_local}"
       end.join(';') + ';'
     end
@@ -320,7 +320,7 @@ END
       @to_merge.each do |type, val, tabs|
         case type
         when :text
-          str << inspect(val)[1...-1]
+          str << inspect_obj(val)[1...-1]
           mtabs += tabs
         when :script
           if mtabs != 0 && !@options[:ugly]
@@ -579,17 +579,17 @@ END
       raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-:\w\.\#]*)(.*)/)[0]
       tag_name, attributes, rest = match
       new_attributes_hash = old_attributes_hash = last_line = object_ref = nil
-      attributes_hashes = []
+      attributes_hashes = {}
       while rest
         case rest[0]
         when ?{
           break if old_attributes_hash
           old_attributes_hash, rest, last_line = parse_old_attributes(rest)
-          attributes_hashes << [:old, old_attributes_hash]
+          attributes_hashes[:old] = old_attributes_hash
         when ?(
           break if new_attributes_hash
           new_attributes_hash, rest, last_line = parse_new_attributes(rest)
-          attributes_hashes << [:new, new_attributes_hash]
+          attributes_hashes[:new] = new_attributes_hash
         when ?[
           break if object_ref
           object_ref, rest = balance(rest, ?[, ?])
@@ -662,7 +662,7 @@ END
         if type == :static
           static_attributes[name] = val
         else
-          dynamic_attributes << inspect(name) << " => " << val << ","
+          dynamic_attributes << inspect_obj(name) << " => " << val << ","
         end
       end
       dynamic_attributes << "}"
@@ -697,7 +697,7 @@ END
 
       return name, [:static, content.first[1]] if content.size == 1
       return name, [:dynamic,
-        '"' + content.map {|(t, v)| t == :str ? inspect(v)[1...-1] : "\#{#{v}}"}.join + '"']
+        '"' + content.map {|(t, v)| t == :str ? inspect_obj(v)[1...-1] : "\#{#{v}}"}.join + '"']
     end
 
     # Parses a line that will render as an XHTML tag, and adds the code that will
@@ -757,16 +757,21 @@ END
       object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
       attributes = Precompiler.parse_class_and_id(attributes)
-      attributes_hashes.map! do |syntax, attributes_hash|
-        if syntax == :old
-          static_attributes = parse_static_hash(attributes_hash)
-          attributes_hash = nil if static_attributes || @options[:suppress_eval]
-        else
-          static_attributes, attributes_hash = attributes_hash
-        end
+      attributes_list = []
+
+      if attributes_hashes[:new]
+        static_attributes, attributes_hash = attributes_hashes[:new]
+        Buffer.merge_attrs(attributes, static_attributes) if static_attributes
+        attributes_list << attributes_hash
+      end
+
+      if attributes_hashes[:old]
+        static_attributes = parse_static_hash(attributes_hashes[:old])
         Buffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_hash
-      end.compact!
+        attributes_list << attributes_hashes[:old] unless static_attributes || @options[:suppress_eval]
+      end
+
+      attributes_list.compact!
 
       raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if block_opened? && self_closing
       raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.", last_line - 1) if parse && value.empty?
@@ -784,7 +789,7 @@ END
         (nuke_inner_whitespace && block_opened?)
 
       # Check if we can render the tag directly to text and not process it in the buffer
-      if object_ref == "nil" && attributes_hashes.empty? && !preserve_script
+      if object_ref == "nil" && attributes_list.empty? && !preserve_script
         tag_closed = !block_opened? && !self_closing && !parse
 
         open_tag  = prerender_tag(tag_name, self_closing, attributes)
@@ -802,19 +807,19 @@ END
         return if tag_closed
       else
         flush_merged_text
-        content = parse ? 'nil' : inspect(value)
-        if attributes_hashes.empty?
-          attributes_hashes = ''
-        elsif attributes_hashes.size == 1
-          attributes_hashes = ", #{attributes_hashes.first}"
+        content = parse ? 'nil' : inspect_obj(value)
+        if attributes_list.empty?
+          attributes_list = ''
+        elsif attributes_list.size == 1
+          attributes_list = ", #{attributes_list.first}"
         else
-          attributes_hashes = ", (#{attributes_hashes.join(").merge(")})"
+          attributes_list = ", (#{attributes_list.join(").merge(")})"
         end
 
         args = [tag_name, self_closing, !block_opened?, preserve_tag, escape_html,
                 attributes, nuke_outer_whitespace, nuke_inner_whitespace
-               ].map {|v| inspect(v)}.join(', ')
-        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hashes})"
+               ].map {|v| inspect_obj(v)}.join(', ')
+        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_list})"
         @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
 
@@ -1019,7 +1024,7 @@ END
 
     def unescape_interpolation(str, opts = {})
       res = ''
-      rest = Haml::Shared.handle_interpolation inspect(str) do |scan|
+      rest = Haml::Shared.handle_interpolation inspect_obj(str) do |scan|
         escapes = (scan[2].size - 1) / 2
         res << scan.matched[0...-3 - escapes]
         if escapes % 2 == 1

data/lib/haml/util.rb

@@ -662,9 +662,9 @@ MSG
     #
     # @param obj {Object}
     # @return {String}
-    def inspect(obj)
+    def inspect_obj(obj)
       return obj.inspect unless version_geq(::RUBY_VERSION, "1.9.2")
-      return ':' + inspect(obj.to_s) if obj.is_a?(Symbol)
+      return ':' + inspect_obj(obj.to_s) if obj.is_a?(Symbol)
       return obj.inspect unless obj.is_a?(String)
       '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
     end

data/lib/sass/engine.rb

@@ -16,6 +16,7 @@ require 'sass/tree/for_node'
 require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
+require 'sass/tree/charset_node'
 require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
@@ -195,7 +196,14 @@ module Sass
     def _render
       rendered = _to_tree.render
       return rendered if ruby1_8?
-      return rendered.encode(source_encoding)
+      begin
+        # Try to convert the result to the original encoding,
+        # but if that doesn't work fall back on UTF-8
+        rendered = rendered.encode(source_encoding)
+      rescue EncodingError
+      end
+      rendered.gsub(Regexp.new('\A@charset "(.*?)"'.encode(source_encoding)),
+        "@charset \"#{source_encoding.name}\"".encode(source_encoding))
     end
 
     def _to_tree
@@ -542,6 +550,12 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::WarnNode.new(parse_script(value, :offset => offset))
+      elsif directive == "charset"
+        name = value && value[/\A(["'])(.*)\1\Z/, 2] #"
+        raise SyntaxError.new("Invalid charset directive '@charset': expected string.") unless name
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath charset directives.",
+          :line => @line + 1) unless line.children.empty?
+        Tree::CharsetNode.new(name)
       else
         Tree::DirectiveNode.new(line.text)
       end

data/lib/sass/plugin.rb

@@ -228,7 +228,10 @@ module Sass
       # Finally, write the file
       flag = 'w'
       flag = 'wb' if Haml::Util.windows? && options[:unix_newlines]
-      File.open(css, flag) {|file| file.print(result)}
+      File.open(css, flag) do |file|
+        file.set_encoding(result.encoding) unless Haml::Util.ruby1_8?
+        file.print(result)
+      end
     end
 
     def try_delete_css(css)

data/lib/sass/scss/css_parser.rb

@@ -24,11 +24,6 @@ module Sass
       def interp_ident(ident = IDENT); tok(ident); end
       def use_css_import?; true; end
 
-      def special_directive(name)
-        return unless name == 'media' || name == 'import'
-        super
-      end
-
       def block_child(context)
         case context
         when :ruleset

data/lib/sass/scss/parser.rb

@@ -98,7 +98,8 @@ module Sass
         node << comment
       end
 
-      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :while, :if, :extend, :import, :media]
+      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :while, :if, :extend, :import,
+        :media, :charset]
 
       def directive
         return unless tok(/@/)
@@ -289,6 +290,13 @@ module Sass
         true
       end
 
+      def charset_directive
+        tok! STRING
+        name = @scanner[1] || @scanner[2]
+        ss
+        node(Sass::Tree::CharsetNode.new(name))
+      end
+
       def variable
         return unless tok(/\$/)
         name = tok!(IDENT)

data/lib/sass/scss/static_parser.rb

@@ -32,7 +32,7 @@ module Sass
       def use_css_import?; true; end
 
       def special_directive(name)
-        return unless name == 'media' || name == 'import'
+        return unless  %w[media import charset].include?(name)
         super
       end
     end

data/lib/sass/tree/charset_node.rb

@@ -0,0 +1,37 @@
+module Sass::Tree
+  # A static node representing an unproccessed Sass `@charset` directive.
+  #
+  # @see Sass::Tree
+  class CharsetNode < Node
+    # The name of the charset.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # @param name [String] see \{#name}
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    # @see Node#invisible?
+    def invisible?
+      !Haml::Util.ruby1_8?
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@charset \"#{name}\"#{semi fmt}\n"
+    end
+
+    # Computes the CSS for the directive.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @return [String] The resulting CSS
+    def _to_s(tabs)
+      "@charset \"#{name}\";"
+    end
+  end
+end

data/lib/sass/tree/directive_node.rb

@@ -4,8 +4,8 @@ module Sass::Tree
   # are handled by their own nodes;
   # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
   #
-  # `@import` is a bit of a weird case;
-  # it becomes an {ImportNode}.
+  # `@import` and `@charset` are special cases;
+  # they become {ImportNode}s and {CharsetNode}s, respectively.
   #
   # @see Sass::Tree
   class DirectiveNode < Node

data/lib/sass/tree/root_node.rb

@@ -47,7 +47,7 @@ module Sass
       # @return [(Tree::Node, Haml::Util::SubsetMap)] The resulting tree of static nodes
       #   *and* the extensions defined for this tree
       def cssize(extends = Haml::Util::SubsetMap.new, parent = nil)
-        return super(extends), extends
+        return super(extends, parent), extends
       rescue Sass::SyntaxError => e
         e.sass_template = @template
         raise e
@@ -106,7 +106,39 @@ module Sass
         end
         result.rstrip!
         return "" if result.empty?
-        return result + "\n"
+        result << "\n"
+        unless Haml::Util.ruby1_8? || result.ascii_only?
+          if children.first.is_a?(CharsetNode)
+            begin
+              encoding = children.first.name
+              # Default to big-endian encoding, because we have to decide somehow
+              encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
+              result = result.encode(Encoding.find(encoding))
+            rescue EncodingError
+            end
+          end
+
+          result = "@charset \"#{result.encoding.name}\";#{
+            style == :compressed ? '' : "\n"
+          }".encode(result.encoding) + result
+        end
+        result
+      end
+
+      # In Ruby 1.8, ensures that there's only one @charset directive
+      # and that it's at the top of the document.
+      #
+      # @see Node#cssize
+      def cssize!(extends, parent)
+        super
+
+        # In Ruby 1.9 we can make all @charset nodes invisible
+        # and infer the final @charset from the encoding of the final string.
+        if Haml::Util.ruby1_8? && parent.nil?
+          charset = self.children.find {|c| c.is_a?(CharsetNode)}
+          self.children.reject! {|c| c.is_a?(CharsetNode)}
+          self.children.unshift charset if charset
+        end
       end
 
       # Returns an error message if the given child node is invalid,

data/test/haml/engine_test.rb

@@ -1389,7 +1389,7 @@ SASS
 
   def test_new_attribute_ids
     assert_equal("<div id='foo_bar'></div>\n", render("#foo(id='bar')"))
-    assert_equal("<div id='foo_bar_baz'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
+    assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo{:id => 'bar'}(id='baz')"))
     assert_equal("<div id='foo_baz_bar'></div>\n", render("#foo(id='baz'){:id => 'bar'}"))
     foo = User.new(42)
     assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
@@ -1398,7 +1398,7 @@ SASS
       render("#foo(id='baz')[foo]{:id => 'bar'}", :locals => {:foo => foo}))
     assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
       render("#foo[foo](id='baz'){:id => 'bar'}", :locals => {:foo => foo}))
-    assert_equal("<div class='struct_user' id='foo_bar_baz_struct_user_42'></div>\n",
+    assert_equal("<div class='struct_user' id='foo_baz_bar_struct_user_42'></div>\n",
       render("#foo[foo]{:id => 'bar'}(id='baz')", :locals => {:foo => foo}))
   end
 
@@ -1470,11 +1470,17 @@ SASS
     assert_equal("<a a='b' c='d'>bar</a>\n", render("%a(c='d'){:a => 'b'} bar"))
     assert_equal("<a a='b' c='d'>bar</a>\n", render("%a{:a => 'b'}(c='d') bar"))
 
-    assert_equal("<a a='d'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
+    # Old-style always takes precedence over new-style,
+    # because theoretically old-style could have arbitrary end-of-method-call syntax.
+    assert_equal("<a a='b'>bar</a>\n", render("%a{:a => 'b'}(a='d') bar"))
     assert_equal("<a a='b'>bar</a>\n", render("%a(a='d'){:a => 'b'} bar"))
 
     assert_equal("<a a='b' b='c' c='d' d='e'>bar</a>\n",
       render("%a{:a => 'b',\n:b => 'c'}(c='d'\nd='e') bar"))
+
+    locals = {:b => 'b', :d => 'd'}
+    assert_equal("<p a='b' c='d'></p>\n", render("%p{:a => b}(c=d)", :locals => locals))
+    assert_equal("<p a='b' c='d'></p>\n", render("%p(a=b){:c => d}", :locals => locals))
   end
 
   # Ruby Multiline

data/test/sass/conversion_test.rb

@@ -607,6 +607,14 @@ foo {
 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

data/test/sass/engine_test.rb

@@ -2128,7 +2128,7 @@ SASS
 
     def test_same_charset_as_encoding
       assert_renders_encoded(<<CSS, <<SASS)
-@charset "utf-8";
+@charset "UTF-8";
 fóó {
   a: b; }
 CSS
@@ -2140,7 +2140,7 @@ SASS
 
     def test_different_charset_than_encoding
       assert_renders_encoded(<<CSS.force_encoding("IBM866"), <<SASS)
-@charset "ibm866";
+@charset "IBM866";
 fóó {
   a: b; }
 CSS
@@ -2152,6 +2152,7 @@ SASS
 
     def test_different_encoding_than_system
       assert_renders_encoded(<<CSS.encode("IBM866"), <<SASS.encode("IBM866"))
+@charset "IBM866";
 тАЬ {
   a: b; }
 CSS
@@ -2161,20 +2162,20 @@ SASS
     end
 
     def test_multibyte_charset
-      assert_renders_encoded(<<CSS.encode("UTF-16BE"), <<SASS.encode("UTF-16BE").force_encoding("UTF-8"))
-@charset "utf-16be";
+      assert_renders_encoded(<<CSS.encode("UTF-16LE"), <<SASS.encode("UTF-16LE").force_encoding("UTF-8"))
+@charset "UTF-16LE";
 fóó {
   a: b; }
 CSS
-@charset "utf-16be"
+@charset "utf-16le"
 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";
+      assert_renders_encoded(<<CSS.encode("UTF-32BE"), <<SASS.encode("UTF-32BE").force_encoding("UTF-8"))
+@charset "UTF-32BE";
 fóó {
   a: b; }
 CSS
@@ -2186,6 +2187,7 @@ SASS
 
     def test_utf8_bom
       assert_renders_encoded(<<CSS, <<SASS.force_encoding("BINARY"))
+@charset "UTF-8";
 fóó {
   a: b; }
 CSS
@@ -2196,6 +2198,7 @@ SASS
 
     def test_utf16le_bom
       assert_renders_encoded(<<CSS.encode("UTF-16LE"), <<SASS.encode("UTF-16LE").force_encoding("BINARY"))
+@charset "UTF-16LE";
 fóó {
   a: b; }
 CSS
@@ -2206,6 +2209,7 @@ SASS
 
     def test_utf32be_bom
       assert_renders_encoded(<<CSS.encode("UTF-32BE"), <<SASS.encode("UTF-32BE").force_encoding("BINARY"))
+@charset "UTF-32BE";
 fóó {
   a: b; }
 CSS

data/test/sass/plugin_test.rb

@@ -9,6 +9,8 @@ class SassPluginTest < Test::Unit::TestCase
     subdir/subdir subdir/nested_subdir/nested_subdir
     options
   }
+  @@templates += %w[import_charset import_charset_ibm866] unless Haml::Util.ruby1_8?
+  @@templates << 'import_charset_1_8' if Haml::Util.ruby1_8?
 
   def setup
     FileUtils.mkdir tempfile_loc
@@ -267,11 +269,18 @@ CSS
     prefix = options[:prefix]
     result_name = arguments.shift
     tempfile_name = arguments.shift || result_name
-    expected_lines = File.read(result_loc(result_name, prefix)).split("\n")
-    actual_lines = File.read(tempfile_loc(tempfile_name, prefix)).split("\n")
+
+    expected_str = File.read(result_loc(result_name, prefix))
+    actual_str = File.read(tempfile_loc(tempfile_name, prefix))
+    unless Haml::Util.ruby1_8?
+      expected_str = expected_str.force_encoding('IBM866') if result_name == 'import_charset_ibm866'
+      actual_str = actual_str.force_encoding('IBM866') if tempfile_name == 'import_charset_ibm866'
+    end
+    expected_lines = expected_str.split("\n")
+    actual_lines = actual_str.split("\n")
 
     if actual_lines.first == "/*" && expected_lines.first != "/*"
-      assert(false, actual_lines[0..actual_lines.enum_with_index.find {|l, i| l == "*/"}.last].join("\n"))
+      assert(false, actual_lines[0..Haml::Util.enum_with_index(actual_lines).find {|l, i| l == "*/"}.last].join("\n"))
     end
 
     expected_lines.zip(actual_lines).each_with_index do |pair, line|

data/test/sass/results/import_charset.css

@@ -0,0 +1,4 @@
+@charset "UTF-8";
+.foo { a: b; }
+
+.bar { a: щ; }

data/test/sass/results/import_charset_1_8.css

@@ -0,0 +1,4 @@
+@charset "IBM866";
+.foo { a: b; }
+
+.bar { a: �; }

data/test/sass/results/import_charset_ibm866.css

@@ -0,0 +1,4 @@
+@charset "IBM866";
+.foo { a: b; }
+
+.bar { a: �; }

data/test/sass/scss/css_test.rb

@@ -49,11 +49,34 @@ baz {bar: baz}
 SCSS
   end
 
-  def test_unicode
-    assert_parses <<SCSS
+  if Haml::Util.ruby1_8?
+    def test_unicode
+      assert_parses <<SCSS
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+SCSS
+      assert_parses <<SCSS
 foo {
   bar: föö bâr; }
 SCSS
+    end
+  else
+    def test_unicode
+      assert_parses <<SCSS
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+SCSS
+      assert_equal <<CSS, render(<<SCSS)
+@charset "UTF-8";
+foo {
+  bar: föö bâr; }
+CSS
+foo {
+  bar: föö bâr; }
+SCSS
+    end
   end
 
   def test_invisible_comments
@@ -429,10 +452,6 @@ SCSS
 
   ## Directives
 
-  def test_charset_directive
-    assert_parses '@charset "utf-8";'
-  end
-
   def test_namespace_directive
     assert_parses '@namespace "http://www.w3.org/Profiles/xhtml1-strict";'
     assert_parses '@namespace url(http://www.w3.org/Profiles/xhtml1-strict);'
@@ -508,11 +527,11 @@ SCSS
   end
 
   def test_blockless_directive_without_semicolon
-    assert_equal "@charset \"utf-8\";\n", render('@charset "utf-8"')
+    assert_equal "@foo \"bar\";\n", render('@foo "bar"')
   end
 
   def test_directive_with_lots_of_whitespace
-    assert_equal "@charset \"utf-16\";\n", render('@charset    "utf-16"  ;')
+    assert_equal "@foo \"bar\";\n", render('@foo    "bar"  ;')
   end
 
   def test_empty_blockless_directive

data/test/sass/templates/_imported_charset_ibm866.sass

@@ -0,0 +1,4 @@
+@charset "IBM866"
+
+.bar
+  a: �

data/test/sass/templates/_imported_charset_utf8.sass

@@ -0,0 +1,4 @@
+@charset "UTF-8"
+
+.bar
+  a: щ

data/test/sass/templates/import_charset.sass

@@ -0,0 +1,7 @@
+.foo
+  a: b
+
+// Even though the imported file is in IBM866,
+// since the root file is in UTF-8/ASCII
+// the output will end up being UTF-8.
+@import "imported_charset_ibm866"

data/test/sass/templates/import_charset_1_8.sass

@@ -0,0 +1,4 @@
+.foo
+  a: b
+
+@import "imported_charset_ibm866"

data/test/sass/templates/import_charset_ibm866.sass

@@ -0,0 +1,9 @@
+@charset "IBM866"
+
+.foo
+  a: b
+
+// Even though the imported file is in UTF-8,
+// since the root file is in IBM866
+// the output will end up being IBM866.
+@import "imported_charset_utf8"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: haml
 version: !ruby/object:Gem::Version 
-  hash: 43
+  hash: 41
   prerelease: false
   segments: 
   - 3
   - 0
-  - 22
-  version: 3.0.22
+  - 23
+  version: 3.0.23
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-19 00:00:00 -07:00
+date: 2010-10-31 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,6 +96,7 @@ files:
 - lib/sass/tree/root_node.rb
 - lib/sass/tree/node.rb
 - lib/sass/tree/if_node.rb
+- lib/sass/tree/charset_node.rb
 - lib/sass/tree/extend_node.rb
 - lib/sass/tree/rule_node.rb
 - lib/sass/tree/mixin_def_node.rb
@@ -192,7 +193,9 @@ files:
 - test/sass/templates/basic.sass
 - test/sass/templates/line_numbers.sass
 - test/sass/templates/nested_bork2.sass
+- test/sass/templates/_imported_charset_utf8.sass
 - test/sass/templates/mixin_bork.sass
+- test/sass/templates/import_charset.sass
 - test/sass/templates/importee.less
 - test/sass/templates/warn.sass
 - test/sass/templates/parent_ref.sass
@@ -209,9 +212,11 @@ files:
 - test/sass/templates/bork3.sass
 - test/sass/templates/nested_mixin_bork.sass
 - test/sass/templates/complex.sass
+- test/sass/templates/import_charset_ibm866.sass
 - test/sass/templates/alt.sass
 - test/sass/templates/scss_import.scss
 - test/sass/templates/compact.sass
+- test/sass/templates/_imported_charset_ibm866.sass
 - test/sass/templates/nested.sass
 - test/sass/templates/subdir/subdir.sass
 - test/sass/templates/subdir/nested_subdir/_nested_partial.sass
@@ -219,6 +224,7 @@ files:
 - test/sass/templates/warn_imported.sass
 - test/sass/templates/options.sass
 - test/sass/templates/bork4.sass
+- test/sass/templates/import_charset_1_8.sass
 - test/sass/templates/nested_bork4.sass
 - test/sass/templates/multiline.sass
 - test/sass/templates/expanded.sass
@@ -248,14 +254,17 @@ files:
 - test/sass/results/alt.css
 - test/sass/results/scss_importee.css
 - test/sass/results/line_numbers.css
+- test/sass/results/import_charset.css
 - test/sass/results/expanded.css
 - test/sass/results/warn.css
 - test/sass/results/script.css
 - test/sass/results/scss_import.css
 - test/sass/results/nested.css
 - test/sass/results/options.css
+- test/sass/results/import_charset_1_8.css
 - test/sass/results/parent_ref.css
 - test/sass/results/multiline.css
+- test/sass/results/import_charset_ibm866.css
 - test/sass/results/subdir/subdir.css
 - test/sass/results/subdir/nested_subdir/nested_subdir.css
 - test/sass/results/warn_imported.css