haml 3.0.25 → 3.1.0.alpha.2

data/lib/haml/helpers/action_view_extensions.rb

@@ -19,7 +19,7 @@ module Haml
       #
       #     <div class="entry show">My Div</div>
       #
-      # Then, in a stylesheet (shown here as {Sass}),
+      # Then, in a stylesheet (shown here as [Sass](http://sass-lang.com)),
       # you could refer to this specific action:
       #
       #     .entry.show

data/lib/haml/html.rb

@@ -3,90 +3,81 @@ require File.dirname(__FILE__) + '/../haml'
 require 'haml/engine'
 require 'rubygems'
 require 'cgi'
-require 'hpricot'
 
 module Haml
   class HTML
     # A module containing utility methods that every Hpricot node
     # should have.
     module Node
-      # We have to do everything in `#included`
-      # rather than including the methods in the module itself
-      # because if we do that, they don't propagate to the already-defined subclasses
-      # of the modules including this.
-      def self.included(base)
-        base.class_eval do
-          # Whether this node has already been converted to Haml.
-          # Only used for text nodes and elements.
-          #
-          # @return [Boolean]
-          attr_accessor :converted_to_haml
-
-          # Returns the Haml representation of the given node.
-          #
-          # @param tabs [Fixnum] The indentation level of the resulting Haml.
-          # @option options (see Haml::HTML#initialize)
-          def to_haml(tabs, options)
-            return "" if converted_to_haml || to_s.strip.empty?
-            text = uninterp(self.to_s)
-            node = next_node
-            while node.is_a?(::Hpricot::Elem) && node.name == "haml:loud"
-              node.converted_to_haml = true
-              text << '#{' <<
-                CGI.unescapeHTML(node.inner_text).gsub(/\n\s*/, ' ').strip << '}'
-
-              if node.next_node.is_a?(::Hpricot::Text)
-                node = node.next_node
-                text << uninterp(node.to_s)
-                node.converted_to_haml = true
-              end
-
-              node = node.next_node
-            end
-            return parse_text_with_interpolation(text, tabs)
+      # Whether this node has already been converted to Haml.
+      # Only used for text nodes and elements.
+      #
+      # @return [Boolean]
+      attr_accessor :converted_to_haml
+
+      # Returns the Haml representation of the given node.
+      #
+      # @param tabs [Fixnum] The indentation level of the resulting Haml.
+      # @option options (see Haml::HTML#initialize)
+      def to_haml(tabs, options)
+        return "" if converted_to_haml || to_s.strip.empty?
+        text = uninterp(self.to_s)
+        node = next_node
+        while node.is_a?(::Hpricot::Elem) && node.name == "haml:loud"
+          node.converted_to_haml = true
+          text << '#{' <<
+            CGI.unescapeHTML(node.inner_text).gsub(/\n\s*/, ' ').strip << '}'
+
+          if node.next_node.is_a?(::Hpricot::Text)
+            node = node.next_node
+            text << uninterp(node.to_s)
+            node.converted_to_haml = true
           end
 
-          private
-
-          def erb_to_interpolation(text, options)
-            return text unless options[:erb]
-            text = CGI.escapeHTML(uninterp(text))
-            %w[<haml:loud> </haml:loud>].each {|str| text.gsub!(CGI.escapeHTML(str), str)}
-            ::Hpricot::XML(text).children.inject("") do |str, elem|
-              if elem.is_a?(::Hpricot::Text)
-                str + CGI.unescapeHTML(elem.to_s)
-              else # <haml:loud> element
-                str + '#{' + CGI.unescapeHTML(elem.innerText.strip) + '}'
-              end
-            end
-          end
+          node = node.next_node
+        end
+        return parse_text_with_interpolation(text, tabs)
+      end
 
-          def tabulate(tabs)
-            '  ' * tabs
-          end
+      private
 
-          def uninterp(text)
-            text.gsub('#{', '\#{') #'
+      def erb_to_interpolation(text, options)
+        return text unless options[:erb]
+        text = CGI.escapeHTML(uninterp(text))
+        %w[<haml:loud> </haml:loud>].each {|str| text.gsub!(CGI.escapeHTML(str), str)}
+        ::Hpricot::XML(text).children.inject("") do |str, elem|
+          if elem.is_a?(::Hpricot::Text)
+            str + CGI.unescapeHTML(elem.to_s)
+          else # <haml:loud> element
+            str + '#{' + CGI.unescapeHTML(elem.innerText.strip) + '}'
           end
+        end
+      end
 
-          def attr_hash
-            attributes.to_hash
-          end
+      def tabulate(tabs)
+        '  ' * tabs
+      end
 
-          def parse_text(text, tabs)
-            parse_text_with_interpolation(uninterp(text), tabs)
-          end
+      def uninterp(text)
+        text.gsub('#{', '\#{') #'
+      end
 
-          def parse_text_with_interpolation(text, tabs)
-            text.strip!
-            return "" if text.empty?
+      def attr_hash
+        attributes.to_hash
+      end
 
-            text.split("\n").map do |line|
-              line.strip!
-              "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
-            end.join
-          end
-        end
+      def parse_text(text, tabs)
+        parse_text_with_interpolation(uninterp(text), tabs)
+      end
+
+      def parse_text_with_interpolation(text, tabs)
+        text.strip!
+        return "" if text.empty?
+
+        text.split("\n").map do |line|
+          line.strip!
+          "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+        end.join
       end
     end
   end
@@ -107,16 +98,11 @@ module Hpricot
   end
 end
 
+require 'hpricot'
+
 # @private
 HAML_TAGS = %w[haml:block haml:loud haml:silent]
 
-HAML_TAGS.each do |t|
-  Hpricot::ElementContent[t] = {}
-  Hpricot::ElementContent.keys.each do |key|
-    Hpricot::ElementContent[t][key.hash] = true
-  end
-end
-
 Hpricot::ElementContent.keys.each do |k|
   HAML_TAGS.each do |el|
     val = Hpricot::ElementContent[k]
@@ -124,6 +110,13 @@ Hpricot::ElementContent.keys.each do |k|
   end
 end
 
+HAML_TAGS.each do |t|
+  Hpricot::ElementContent[t] = {}
+  Hpricot::ElementContent.keys.each do |key|
+    Hpricot::ElementContent[t][key.hash] = true
+  end
+end
+
 module Haml
   # Converts HTML documents into Haml templates.
   # Depends on [Hpricot](http://github.com/whymirror/hpricot) for HTML parsing.

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_obj(name.to_sym)}]"
-        str_local = "_haml_locals[#{inspect_obj(name.to_s)}]"
+        sym_local = "_haml_locals[#{name.to_sym.inspect}]"
+        str_local = "_haml_locals[#{name.to_s.inspect}]"
         "#{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_obj(val)[1...-1]
+          str << val.inspect[1...-1]
           mtabs += tabs
         when :script
           if mtabs != 0 && !@options[:ugly]
@@ -336,14 +336,12 @@ END
         end
       end
 
-      unless str.empty?
-        @precompiled <<
-          if @options[:ugly]
-            "_hamlout.buffer << \"#{str}\";"
-          else
-            "_hamlout.push_text(\"#{str}\", #{mtabs}, #{@dont_tab_up_next_text.inspect});"
-          end
-      end
+      @precompiled <<
+        if @options[:ugly]
+          "_hamlout.buffer << \"#{str}\";"
+        else
+          "_hamlout.push_text(\"#{str}\", #{mtabs}, #{@dont_tab_up_next_text.inspect});"
+        end
       @precompiled << "\n" * newlines
       @to_merge = []
       @dont_tab_up_next_text = false
@@ -579,17 +577,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 +660,7 @@ END
         if type == :static
           static_attributes[name] = val
         else
-          dynamic_attributes << inspect_obj(name) << " => " << val << ","
+          dynamic_attributes << name.inspect << " => " << val << ","
         end
       end
       dynamic_attributes << "}"
@@ -697,7 +695,7 @@ END
 
       return name, [:static, content.first[1]] if content.size == 1
       return name, [:dynamic,
-        '"' + content.map {|(t, v)| t == :str ? inspect_obj(v)[1...-1] : "\#{#{v}}"}.join + '"']
+        '"' + content.map {|(t, v)| t == :str ? v.inspect[1...-1] : "\#{#{v}}"}.join + '"']
     end
 
     # Parses a line that will render as an XHTML tag, and adds the code that will
@@ -757,21 +755,16 @@ END
       object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
       attributes = Precompiler.parse_class_and_id(attributes)
-      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])
+      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
         Buffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hashes[:old] unless static_attributes || @options[:suppress_eval]
-      end
-
-      attributes_list.compact!
+        attributes_hash
+      end.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?
@@ -789,7 +782,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_list.empty? && !preserve_script
+      if object_ref == "nil" && attributes_hashes.empty? && !preserve_script
         tag_closed = !block_opened? && !self_closing && !parse
 
         open_tag  = prerender_tag(tag_name, self_closing, attributes)
@@ -807,19 +800,19 @@ END
         return if tag_closed
       else
         flush_merged_text
-        content = parse ? 'nil' : inspect_obj(value)
-        if attributes_list.empty?
-          attributes_list = ''
-        elsif attributes_list.size == 1
-          attributes_list = ", #{attributes_list.first}"
+        content = parse ? 'nil' : value.inspect
+        if attributes_hashes.empty?
+          attributes_hashes = ''
+        elsif attributes_hashes.size == 1
+          attributes_hashes = ", #{attributes_hashes.first}"
         else
-          attributes_list = ", (#{attributes_list.join(").merge(")})"
+          attributes_hashes = ", (#{attributes_hashes.join(").merge(")})"
         end
 
         args = [tag_name, self_closing, !block_opened?, preserve_tag, escape_html,
                 attributes, nuke_outer_whitespace, nuke_inner_whitespace
-               ].map {|v| inspect_obj(v)}.join(', ')
-        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_list})"
+               ].map { |v| v.inspect }.join(', ')
+        push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hashes})"
         @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
 
@@ -1024,14 +1017,14 @@ END
 
     def unescape_interpolation(str, opts = {})
       res = ''
-      rest = Haml::Shared.handle_interpolation inspect_obj(str) do |scan|
+      rest = Haml::Shared.handle_interpolation str.dump do |scan|
         escapes = (scan[2].size - 1) / 2
         res << scan.matched[0...-3 - escapes]
         if escapes % 2 == 1
           res << '#{'
         else
           content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
-          content = "Haml::Helpers.html_escape((#{content}))" if opts[:escape_html]
+          content = "Haml::Helpers.html_escape(#{content})" if opts[:escape_html]
           res << '#{' + content + "}"# Use eval to get rid of string escapes
         end
       end

data/lib/haml/railtie.rb

@@ -1,6 +1,6 @@
 if Haml::Util.ap_geq_3? && !Haml::Util.ap_geq?("3.0.0.beta4")
   raise <<ERROR
-Haml and Sass no longer support Rails 3 versions before beta 4.
+Haml no longer supports Rails 3 versions before beta 4.
   Please upgrade to Rails 3.0.0.beta4 or later.
 ERROR
 end
@@ -8,12 +8,10 @@ end
 # Rails 3.0.0.beta.2+
 if defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load)
   require 'haml/template/options'
-  require 'sass/plugin/configuration'
+  autoload(:Sass, 'sass/rails3_shim')
   ActiveSupport.on_load(:before_initialize) do
-    require 'sass'
-    require 'sass/plugin'
-
-    # Haml requires AV, but Sass doesn't
+    # resolve autoload if it looks like they're using Sass without options
+    Sass if File.exist?(File.join(Rails.root, 'public/stylesheets/sass'))
     ActiveSupport.on_load(:action_view) do
       Haml.init_rails(binding)
     end

data/lib/haml/template/plugin.rb

@@ -2,17 +2,12 @@
 # using the > 2.0.1 template handler API.
 
 module Haml
-  # In Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they do.
-  # To avoid messy logic figuring this out, we just inherit from whatever the ERB handler does.
-  class Plugin < Haml::Util.av_template_class(:Handlers)::ERB.superclass
-    if ((defined?(ActionView::TemplateHandlers) &&
-          defined?(ActionView::TemplateHandlers::Compilable)) ||
-        (defined?(ActionView::Template) &&
-          defined?(ActionView::Template::Handlers) &&
-          defined?(ActionView::Template::Handlers::Compilable))) &&
-        # In Rails 3.1+, we don't need to include Compilable.
-        Haml::Util.av_template_class(:Handlers)::ERB.include?(
-          Haml::Util.av_template_class(:Handlers)::Compilable)
+  class Plugin < Haml::Util.av_template_class(:Handler)
+    if (defined?(ActionView::TemplateHandlers) &&
+        defined?(ActionView::TemplateHandlers::Compilable)) ||
+       (defined?(ActionView::Template) &&
+        defined?(ActionView::Template::Handlers) &&
+        defined?(ActionView::Template::Handlers::Compilable))
       include Haml::Util.av_template_class(:Handlers)::Compilable
     end
 
@@ -34,11 +29,6 @@ module Haml
       Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
     end
 
-    # In Rails 3.1+, #call takes the place of #compile
-    def self.call(template)
-      new.compile(template)
-    end
-
     def cache_fragment(block, name = {}, options = nil)
       @view.fragment_for(block, name, options) do
         eval("_hamlout.buffer", block.binding)

data/lib/haml/util.rb

@@ -6,7 +6,6 @@ require 'strscan'
 require 'rbconfig'
 
 require 'haml/root'
-require 'haml/util/subset_map'
 
 module Haml
   # A module containing various useful functions.
@@ -17,11 +16,6 @@ module Haml
     # @api public
     RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
 
-    # The Ruby engine we're running under. Defaults to `"ruby"`
-    # if the top-level constant is undefined.
-    # @api public
-    RUBY_ENGINE = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "ruby"
-
     # Returns the path of a file relative to the Haml root directory.
     #
     # @param file [String] The filename relative to the Haml root
@@ -31,11 +25,10 @@ module Haml
     end
 
     # Converts an array of `[key, value]` pairs to a hash.
-    # For example:
-    #
-    #     to_hash([[:foo, "bar"], [:baz, "bang"]])
-    #       #=> {:foo => "bar", :baz => "bang"}
     #
+    # @example
+    #   to_hash([[:foo, "bar"], [:baz, "bang"]])
+    #     #=> {:foo => "bar", :baz => "bang"}
     # @param arr [Array<(Object, Object)>] An array of pairs
     # @return [Hash] A hash
     def to_hash(arr)
@@ -43,11 +36,10 @@ module Haml
     end
 
     # Maps the keys in a hash according to a block.
-    # For example:
-    #
-    #     map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
-    #       #=> {"foo" => "bar", "baz" => "bang"}
     #
+    # @example
+    #   map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
+    #     #=> {"foo" => "bar", "baz" => "bang"}
     # @param hash [Hash] The hash to map
     # @yield [key] A block in which the keys are transformed
     # @yieldparam key [Object] The key that should be mapped
@@ -60,11 +52,10 @@ module Haml
     end
 
     # Maps the values in a hash according to a block.
-    # For example:
-    #
-    #     map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
-    #       #=> {:foo => :bar, :baz => :bang}
     #
+    # @example
+    #   map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
+    #     #=> {:foo => :bar, :baz => :bang}
     # @param hash [Hash] The hash to map
     # @yield [value] A block in which the values are transformed
     # @yieldparam value [Object] The value that should be mapped
@@ -77,11 +68,10 @@ module Haml
     end
 
     # Maps the key-value pairs of a hash according to a block.
-    # For example:
-    #
-    #     map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
-    #       #=> {"foo" => :bar, "baz" => :bang}
     #
+    # @example
+    #   map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
+    #     #=> {"foo" => :bar, "baz" => :bang}
     # @param hash [Hash] The hash to map
     # @yield [key, value] A block in which the key-value pairs are transformed
     # @yieldparam [key] The hash key
@@ -96,11 +86,10 @@ module Haml
 
     # Computes the powerset of the given array.
     # This is the set of all subsets of the array.
-    # For example:
-    #
-    #     powerset([1, 2, 3]) #=>
-    #       Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
     #
+    # @example
+    #   powerset([1, 2, 3]) #=>
+    #     Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
     # @param arr [Enumerable]
     # @return [Set<Set>] The subsets of `arr`
     def powerset(arr)
@@ -127,11 +116,10 @@ module Haml
 
     # Concatenates all strings that are adjacent in an array,
     # while leaving other elements as they are.
-    # For example:
-    #
-    #     merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
-    #       #=> [1, "foobar", 2, "baz"]
     #
+    # @example
+    #   merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
+    #     #=> [1, "foobar", 2, "baz"]
     # @param enum [Enumerable]
     # @return [Array] The enumerable with strings merged
     def merge_adjacent_strings(enum)
@@ -194,11 +182,11 @@ module Haml
     # @return [Array<Arrays>]
     #
     # @example
-    # paths([[1, 2], [3, 4], [5]]) #=>
-    #   # [[1, 3, 5],
-    #   #  [2, 3, 5],
-    #   #  [1, 4, 5],
-    #   #  [2, 4, 5]]
+    #   paths([[1, 2], [3, 4], [5]]) #=>
+    #     # [[1, 3, 5],
+    #     #  [2, 3, 5],
+    #     #  [1, 4, 5],
+    #     #  [2, 4, 5]]
     def paths(arrs)
       arrs.inject([[]]) do |paths, arr|
         flatten(arr.map {|e| paths.map {|path| path + [e]}}, 1)
@@ -274,6 +262,43 @@ module Haml
       version_gt(v1, v2) || !version_gt(v2, v1)
     end
 
+    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
+    # before dumping it, `#_after_dump` afterwards.
+    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
+    #
+    # If any of these methods are undefined, they are not called.
+    #
+    # @param obj [Object] The object to dump.
+    # @return [String] The dumped data.
+    def dump(obj)
+      obj._before_dump if obj.respond_to?(:_before_dump)
+      return Marshal.dump(obj) unless obj.respond_to?(:_around_dump)
+      res = nil
+      obj._around_dump {res = Marshal.dump(obj)}
+      res
+    ensure
+      obj._after_dump if obj.respond_to?(:_after_dump)
+    end
+
+    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
+    # after loading it, if it's defined.
+    #
+    # @param data [String] The data to load.
+    # @return [Object] The loaded object.
+    def load(data)
+      obj = Marshal.load(data)
+      obj._after_load if obj.respond_to?(:_after_load)
+      obj
+    end
+
+    # Throws a NotImplementedError for an abstract method.
+    #
+    # @param obj [Object] `self`
+    # @raise [NotImplementedError]
+    def abstract(obj)
+      raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
+    end
+
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -304,6 +329,35 @@ module Haml
       warn(msg)
     end
 
+    # Try loading Sass. If the `sass` gem isn't installed,
+    # print a warning and load from the vendored gem.
+    #
+    # @return [Boolean] True if Sass was successfully loaded from the `sass` gem,
+    #   false otherwise.
+    def try_sass
+      return true if defined?(::SASS_BEGUN_TO_LOAD)
+      begin
+        require 'sass/version'
+        loaded = Sass.respond_to?(:version) && Sass.version[:major] &&
+          Sass.version[:minor] && ((Sass.version[:major] > 3 && Sass.version[:minor] > 1) ||
+          ((Sass.version[:major] == 3 && Sass.version[:minor] == 1) &&
+            (Sass.version[:prerelease] || Sass.version[:name] != "Bleeding Edge")))
+      rescue LoadError => e
+        loaded = false
+      end
+
+      unless loaded
+        haml_warn(<<WARNING)
+Sass is in the process of being separated from Haml,
+and will no longer be bundled at all in Haml 3.2.0.
+Please install the 'sass' gem if you want to use Sass.
+WARNING
+        $".delete('sass/version')
+        $LOAD_PATH.unshift(scope("vendor/sass/lib"))
+      end
+      loaded
+    end
+
     ## Cross Rails Version Compatibility
 
     # Returns the root of the Rails application,
@@ -420,25 +474,13 @@ module Haml
       RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
     end
 
-    # Whether or not this is running on IronRuby.
-    #
-    # @return [Boolean]
-    def ironruby?
-      RUBY_ENGINE == "ironruby"
-    end
-
     ## Cross-Ruby-Version Compatibility
 
     # Whether or not this is running under Ruby 1.8 or lower.
     #
-    # Note that IronRuby counts as Ruby 1.8,
-    # because it doesn't support the Ruby 1.9 encoding API.
-    #
     # @return [Boolean]
     def ruby1_8?
-      # IronRuby says its version is 1.9, but doesn't support any of the encoding APIs.
-      # We have to fall back to 1.8 behavior.
-      ironruby? || (Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9)
+      Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
     end
 
     # Whether or not this is running under Ruby 1.8.6 or lower.
@@ -488,7 +530,7 @@ MSG
     # 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.
+    # The Haml 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.
@@ -517,51 +559,6 @@ MSG
       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)
@@ -673,19 +670,6 @@ MSG
       set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})
     end
 
-    # Like `Object#inspect`, but preserves non-ASCII characters rather than escaping them under Ruby 1.9.2.
-    # This is necessary so that the precompiled Haml template can be `#encode`d into `@options[:encoding]`
-    # before being evaluated.
-    #
-    # @param obj {Object}
-    # @return {String}
-    def inspect_obj(obj)
-      return obj.inspect unless version_geq(::RUBY_VERSION, "1.9.2")
-      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
-
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.