hamlit 2.11.1 → 2.14.1

data/lib/hamlit/parser/haml_error.rb

@@ -1,31 +1,33 @@
+# frozen_string_literal: true
+
 module Hamlit
   # An exception raised by Haml code.
   class HamlError < StandardError
 
     MESSAGES = {
-      :bad_script_indent            => '"%s" is indented at wrong level: expected %d, but was at %d.',
-      :cant_run_filter              => 'Can\'t run "%s" filter; you must require its dependencies first',
-      :cant_use_tabs_and_spaces     => "Indentation can't use both tabs and spaces.",
-      :deeper_indenting             => "The line was indented %d levels deeper than the previous line.",
-      :filter_not_defined           => 'Filter "%s" is not defined.',
-      :gem_install_filter_deps      => '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
-      :illegal_element              => "Illegal element: classes and ids must have values.",
-      :illegal_nesting_content      => "Illegal nesting: nesting within a tag that already has content is illegal.",
-      :illegal_nesting_header       => "Illegal nesting: nesting within a header command is illegal.",
-      :illegal_nesting_line         => "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
-      :illegal_nesting_plain        => "Illegal nesting: nesting within plain text is illegal.",
-      :illegal_nesting_self_closing => "Illegal nesting: nesting within a self-closing tag is illegal.",
-      :inconsistent_indentation     => "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
-      :indenting_at_start           => "Indenting at the beginning of the document is illegal.",
-      :install_haml_contrib         => 'To use the "%s" filter, please install the haml-contrib gem.',
-      :invalid_attribute_list       => 'Invalid attribute list: %s.',
-      :invalid_filter_name          => 'Invalid filter name ":%s".',
-      :invalid_tag                  => 'Invalid tag: "%s".',
-      :missing_if                   => 'Got "%s" with no preceding "if"',
-      :no_ruby_code                 => "There's no Ruby code for %s to evaluate.",
-      :self_closing_content         => "Self-closing tags can't have content.",
-      :unbalanced_brackets          => 'Unbalanced brackets.',
-      :no_end                       => <<-END
+      bad_script_indent:            '"%s" is indented at wrong level: expected %d, but was at %d.',
+      cant_run_filter:              'Can\'t run "%s" filter; you must require its dependencies first',
+      cant_use_tabs_and_spaces:     "Indentation can't use both tabs and spaces.",
+      deeper_indenting:             "The line was indented %d levels deeper than the previous line.",
+      filter_not_defined:           'Filter "%s" is not defined.',
+      gem_install_filter_deps:      '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
+      illegal_element:              "Illegal element: classes and ids must have values.",
+      illegal_nesting_content:      "Illegal nesting: nesting within a tag that already has content is illegal.",
+      illegal_nesting_header:       "Illegal nesting: nesting within a header command is illegal.",
+      illegal_nesting_line:         "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
+      illegal_nesting_plain:        "Illegal nesting: nesting within plain text is illegal.",
+      illegal_nesting_self_closing: "Illegal nesting: nesting within a self-closing tag is illegal.",
+      inconsistent_indentation:     "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
+      indenting_at_start:           "Indenting at the beginning of the document is illegal.",
+      install_haml_contrib:         'To use the "%s" filter, please install the haml-contrib gem.',
+      invalid_attribute_list:       'Invalid attribute list: %s.',
+      invalid_filter_name:          'Invalid filter name ":%s".',
+      invalid_tag:                  'Invalid tag: "%s".',
+      missing_if:                   'Got "%s" with no preceding "if"',
+      no_ruby_code:                 "There's no Ruby code for %s to evaluate.",
+      self_closing_content:         "Self-closing tags can't have content.",
+      unbalanced_brackets:          'Unbalanced brackets.',
+      no_end:                       <<-END
 You don't need to use "- end" in Haml. Un-indent to close a block:
 - if foo?
   %strong Foo!
@@ -33,7 +35,7 @@ You don't need to use "- end" in Haml. Un-indent to close a block:
   Not foo.
 %p This line is un-indented, so it isn't part of the "if" block
 END
-    }
+    }.freeze
 
     def self.message(key, *args)
       string = MESSAGES[key] or raise "[HAML BUG] No error messages for #{key}"
@@ -56,6 +58,8 @@ END
   # SyntaxError is the type of exception raised when Haml encounters an
   # ill-formatted document.
   # It's not particularly interesting,
-  # except in that it's a subclass of {Haml::Error}.
+  # except in that it's a subclass of {Hamlit::HamlError}.
   class HamlSyntaxError < HamlError; end
+
+  class HamlInvalidAttributeNameError < HamlSyntaxError; end
 end

data/lib/hamlit/parser/haml_escapable.rb

@@ -0,0 +1 @@
+class Hamlit::HamlEscapable; end

data/lib/hamlit/parser/haml_generator.rb

@@ -0,0 +1 @@
+class Hamlit::HamlGenerator; end

data/lib/hamlit/parser/haml_helpers.rb

@@ -1,11 +1,10 @@
-require 'hamlit/parser/haml_error'
-require 'hamlit/parser/haml_options'
-require 'hamlit/parser/haml_compiler'
-require 'hamlit/parser/haml_parser'
+# frozen_string_literal: true
+
+require 'erb'
 
 module Hamlit
   # This module contains various helpful methods to make it easier to do various tasks.
-  # {Haml::Helpers} is automatically included in the context
+  # {Hamlit::HamlHelpers} is automatically included in the context
   # that a Haml template is parsed in, so all these methods are at your
   # disposal from within the template.
   module HamlHelpers
@@ -23,10 +22,10 @@ MESSAGE
 
       # Raises an error.
       #
-      # @raise [Haml::Error] The error
+      # @raise [Hamlit::HamlError] The error
       def to_s
-        raise ::Hamlit::HamlError.new(@message)
-      rescue ::Hamlit::HamlError => e
+        raise Hamlit::HamlError.new(@message)
+      rescue Hamlit::HamlError => e
         e.backtrace.shift
 
         # If the ErrorReturn is used directly in the template,
@@ -45,7 +44,7 @@ MESSAGE
 
       # @return [String] A human-readable string representation
       def inspect
-        "::Hamlit::HamlHelpers::ErrorReturn(#{@message.inspect})"
+        "Hamlit::HamlHelpers::ErrorReturn(#{@message.inspect})"
       end
     end
 
@@ -69,13 +68,13 @@ MESSAGE
     #
     #     context = Object.new
     #     class << context
-    #       include Haml::Helpers
+    #       include Hamlit::HamlHelpers
     #     end
     #     context.init_haml_helpers
     #     context.haml_tag :p, "Stuff"
     #
     def init_haml_helpers
-      @haml_buffer = ::Hamlit::HamlBuffer.new(haml_buffer, ::Hamlit::HamlOptions.new.for_buffer)
+      @haml_buffer = Hamlit::HamlBuffer.new(haml_buffer, HamlOptions.new.for_buffer)
       nil
     end
 
@@ -111,10 +110,7 @@ MESSAGE
     #   @yield The block within which to escape newlines
     def find_and_preserve(input = nil, tags = haml_buffer.options[:preserve], &block)
       return find_and_preserve(capture_haml(&block), input || tags) if block
-      tags = tags.each_with_object('') do |t, s|
-        s << '|' unless s.empty?
-        s << Regexp.escape(t)
-      end
+      tags = tags.map { |tag| Regexp.escape(tag) }.join('|')
       re = /<(#{tags})([^>]*)>(.*?)(<\/\1>)/im
       input.to_s.gsub(re) do |s|
         s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
@@ -202,20 +198,19 @@ MESSAGE
     # @yield [item] A block which contains Haml code that goes within list items
     # @yieldparam item An element of `enum`
     def list_of(enum, opts={}, &block)
-      opts_attributes = opts.each_with_object('') {|(k, v), s| s << " #{k}='#{v}'"}
-      enum.each_with_object('') do |i, ret|
+      opts_attributes = opts.map { |k, v| " #{k}='#{v}'" }.join
+      enum.map do |i|
         result = capture_haml(i, &block)
 
         if result.count("\n") > 1
           result.gsub!("\n", "\n  ")
-          result = "\n  #{result.strip!}\n"
+          result = "\n  #{result.strip}\n"
         else
           result.strip!
         end
 
-        ret << "\n" unless ret.empty?
-        ret << %Q!<li#{opts_attributes}>#{result}</li>!
-      end
+        %Q!<li#{opts_attributes}>#{result}</li>!
+      end.join("\n")
     end
 
     # Returns a hash containing default assignments for the `xmlns`, `lang`, and `xml:lang`
@@ -389,8 +384,7 @@ MESSAGE
           captured = (value.is_a?(String) ? value : nil)
         end
 
-        return nil if captured.nil?
-        return (haml_buffer.options[:ugly] ? captured : prettify(captured))
+        captured
       end
     ensure
       haml_buffer.capture_position = nil
@@ -417,7 +411,7 @@ MESSAGE
     # @param newline [Boolean] Whether to add a newline after the text
     # @param indent [Boolean] Whether to add indentation to the first line
     def haml_internal_concat(text = "", newline = true, indent = true)
-      if haml_buffer.options[:ugly] || haml_buffer.tabulation == 0
+      if haml_buffer.tabulation == 0
         haml_buffer.buffer << "#{text}#{"\n" if newline}"
       else
         haml_buffer.buffer << %[#{haml_indent if indent}#{text.to_s.gsub("\n", "\n#{haml_indent}")}#{"\n" if newline}]
@@ -501,7 +495,7 @@ MESSAGE
       attrs.keys.each {|key| attrs[key.to_s] = attrs.delete(key)} unless attrs.empty?
       name, attrs = merge_name_and_attributes(name.to_s, attrs)
 
-      attributes = ::Hamlit::HamlCompiler.build_attributes(haml_buffer.html?,
+      attributes = Hamlit::HamlAttributeBuilder.build_attributes(haml_buffer.html?,
         haml_buffer.options[:attr_wrapper],
         haml_buffer.options[:escape_attrs],
         haml_buffer.options[:hyphenate_data_attrs],
@@ -513,8 +507,8 @@ MESSAGE
       end
 
       if flags.include?(:/)
-        raise ::Hamlit::HamlError.new(::Hamlit::HamlError.message(:self_closing_content)) if text
-        raise ::Hamlit::HamlError.new(::Hamlit::HamlError.message(:illegal_nesting_self_closing)) if block
+        raise HamlError.new(HamlError.message(:self_closing_content)) if text
+        raise HamlError.new(HamlError.message(:illegal_nesting_self_closing)) if block
       end
 
       tag = "<#{name}#{attributes}>"
@@ -536,7 +530,7 @@ MESSAGE
       end
 
       if text
-        raise ::Hamlit::HamlError.new(::Hamlit::HamlError.message(:illegal_nesting_line, name))
+        raise HamlError.new(HamlError.message(:illegal_nesting_line, name))
       end
 
       if flags.include?(:<)
@@ -599,9 +593,9 @@ MESSAGE
     end
 
     # Characters that need to be escaped to HTML entities from user input
-    HTML_ESCAPE = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#039;' }
+    HTML_ESCAPE = {'&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#39;'}.freeze
 
-    HTML_ESCAPE_REGEX = /[\"><&]/
+    HTML_ESCAPE_REGEX = /['"><&]/
 
     # Returns a copy of `text` with ampersands, angle brackets and quotes
     # escaped into HTML entities.
@@ -613,11 +607,13 @@ MESSAGE
     # @param text [String] The string to sanitize
     # @return [String] The sanitized string
     def html_escape(text)
-      text = text.to_s
-      text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE)
+      CGI.escapeHTML(text.to_s)
     end
 
-    HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/
+    # Always escape text regardless of html_safe?
+    alias_method :html_escape_without_haml_xss, :html_escape
+
+    HTML_ESCAPE_ONCE_REGEX = /['"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/
 
     # Escapes HTML entities in `text`, but without escaping an ampersand
     # that is already part of an escaped entity.
@@ -629,9 +625,12 @@ MESSAGE
       text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
     end
 
+    # Always escape text once regardless of html_safe?
+    alias_method :escape_once_without_haml_xss, :escape_once
+
     # Returns whether or not the current template is a Haml template.
     #
-    # This function, unlike other {Haml::Helpers} functions,
+    # This function, unlike other {Hamlit::HamlHelpers} functions,
     # also works in other `ActionView` templates,
     # where it will always return false.
     #
@@ -656,13 +655,13 @@ MESSAGE
       # skip merging if no ids or classes found in name
       return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
 
-      return $1 || "div", ::Hamlit::HamlBuffer.merge_attrs(
-        ::Hamlit::HamlParser.parse_class_and_id($2), attributes_hash)
+      return $1 || "div", HamlAttributeBuilder.merge_attributes!(
+        Hamlit::HamlParser.parse_class_and_id($2), attributes_hash)
     end
 
     # Runs a block of code with the given buffer as the currently active buffer.
     #
-    # @param buffer [Haml::Buffer] The Haml buffer to use temporarily
+    # @param buffer [Hamlit::HamlBuffer] The Haml buffer to use temporarily
     # @yield A block in which the given buffer should be used
     def with_haml_buffer(buffer)
       @haml_buffer, old_buffer = buffer, @haml_buffer
@@ -675,9 +674,9 @@ MESSAGE
       @haml_buffer = old_buffer
     end
 
-    # The current {Haml::Buffer} object.
+    # The current {Hamlit::HamlBuffer} object.
     #
-    # @return [Haml::Buffer]
+    # @return [Hamlit::HamlBuffer]
     def haml_buffer
       @haml_buffer if defined? @haml_buffer
     end
@@ -693,22 +692,6 @@ MESSAGE
       _erbout = _erbout = _hamlout.buffer
       proc { |*args| proc.call(*args) }
     end
-
-    def prettify(text)
-      text = text.split(/^/)
-      text.delete('')
-
-      min_tabs = nil
-      text.each do |line|
-        tabs = line.index(/[^ ]/) || line.length
-        min_tabs ||= tabs
-        min_tabs = min_tabs > tabs ? tabs : min_tabs
-      end
-
-      text.each_with_object('') do |line, str|
-        str << line.slice(min_tabs, line.length)
-      end
-    end
   end
 end
 
@@ -720,8 +703,7 @@ class Object
   # is a proper Haml context.
   # Because `ActionView` helpers may be included in non-`ActionView::Base` classes,
   # it's a good idea to define \{#is\_haml?} for all objects.
-  def is_haml?
-    false
-  end
-  alias :is_haml? :is_haml?
+  # def is_haml?
+  #   false
+  # end
 end

data/lib/hamlit/parser/{haml_xss_mods.rb → haml_helpers/xss_mods.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hamlit
   module HamlHelpers
     # This module overrides Haml helpers to work properly
@@ -6,12 +8,15 @@ module Hamlit
     # to work with Rails' XSS protection methods.
     module XssMods
       def self.included(base)
-        %w[html_escape find_and_preserve preserve list_of surround
-           precede succeed capture_haml haml_concat haml_internal_concat haml_indent
-           escape_once].each do |name|
+        %w[find_and_preserve preserve list_of surround
+           precede succeed capture_haml haml_concat haml_internal_concat haml_indent].each do |name|
           base.send(:alias_method, "#{name}_without_haml_xss", name)
           base.send(:alias_method, name, "#{name}_with_haml_xss")
         end
+        # Those two always have _without_haml_xss
+        %w[html_escape escape_once].each do |name|
+          base.send(:alias_method, name, "#{name}_with_haml_xss")
+        end
       end
 
       # Don't escape text that's already safe,
@@ -19,27 +24,27 @@ module Hamlit
       def html_escape_with_haml_xss(text)
         str = text.to_s
         return text if str.html_safe?
-        ::Hamlit::HamlUtil.html_safe(html_escape_without_haml_xss(str))
+        Hamlit::HamlUtil.html_safe(html_escape_without_haml_xss(str))
       end
 
       # Output is always HTML safe
       def find_and_preserve_with_haml_xss(*args, &block)
-        ::Hamlit::HamlUtil.html_safe(find_and_preserve_without_haml_xss(*args, &block))
+        Hamlit::HamlUtil.html_safe(find_and_preserve_without_haml_xss(*args, &block))
       end
 
       # Output is always HTML safe
       def preserve_with_haml_xss(*args, &block)
-        ::Hamlit::HamlUtil.html_safe(preserve_without_haml_xss(*args, &block))
+        Hamlit::HamlUtil.html_safe(preserve_without_haml_xss(*args, &block))
       end
 
       # Output is always HTML safe
       def list_of_with_haml_xss(*args, &block)
-        ::Hamlit::HamlUtil.html_safe(list_of_without_haml_xss(*args, &block))
+        Hamlit::HamlUtil.html_safe(list_of_without_haml_xss(*args, &block))
       end
 
       # Input is escaped, output is always HTML safe
       def surround_with_haml_xss(front, back = front, &block)
-        ::Hamlit::HamlUtil.html_safe(
+        Hamlit::HamlUtil.html_safe(
           surround_without_haml_xss(
             haml_xss_html_escape(front),
             haml_xss_html_escape(back),
@@ -48,21 +53,21 @@ module Hamlit
 
       # Input is escaped, output is always HTML safe
       def precede_with_haml_xss(str, &block)
-        ::Hamlit::HamlUtil.html_safe(precede_without_haml_xss(haml_xss_html_escape(str), &block))
+        Hamlit::HamlUtil.html_safe(precede_without_haml_xss(haml_xss_html_escape(str), &block))
       end
 
       # Input is escaped, output is always HTML safe
       def succeed_with_haml_xss(str, &block)
-        ::Hamlit::HamlUtil.html_safe(succeed_without_haml_xss(haml_xss_html_escape(str), &block))
+        Hamlit::HamlUtil.html_safe(succeed_without_haml_xss(haml_xss_html_escape(str), &block))
       end
 
       # Output is always HTML safe
       def capture_haml_with_haml_xss(*args, &block)
-        ::Hamlit::HamlUtil.html_safe(capture_haml_without_haml_xss(*args, &block))
+        Hamlit::HamlUtil.html_safe(capture_haml_without_haml_xss(*args, &block))
       end
 
       # Input will be escaped unless this is in a `with_raw_haml_concat`
-      # block. See #Haml::Helpers::ActionViewExtensions#with_raw_haml_concat.
+      # block. See #Hamlit::HamlHelpers::ActionViewExtensions#with_raw_haml_concat.
       def haml_concat_with_haml_xss(text = "")
         raw = instance_variable_defined?(:@_haml_concat_raw) ? @_haml_concat_raw : false
         if raw
@@ -81,12 +86,12 @@ module Hamlit
 
       # Output is always HTML safe
       def haml_indent_with_haml_xss
-        ::Hamlit::HamlUtil.html_safe(haml_indent_without_haml_xss)
+        Hamlit::HamlUtil.html_safe(haml_indent_without_haml_xss)
       end
 
       # Output is always HTML safe
       def escape_once_with_haml_xss(*args)
-        ::Hamlit::HamlUtil.html_safe(escape_once_without_haml_xss(*args))
+        Hamlit::HamlUtil.html_safe(escape_once_without_haml_xss(*args))
       end
 
       private
@@ -94,7 +99,7 @@ module Hamlit
       # Escapes the HTML in the text if and only if
       # Rails XSS protection is enabled *and* the `:escape_html` option is set.
       def haml_xss_html_escape(text)
-        return text unless ::Hamlit::HamlUtil.rails_xss_safe? && haml_buffer.options[:escape_html]
+        return text unless Hamlit::HamlUtil.rails_xss_safe? && haml_buffer.options[:escape_html]
         html_escape(text)
       end
     end

data/lib/hamlit/parser/haml_options.rb

@@ -1,58 +1,45 @@
-require 'hamlit/parser/haml_parser'
-require 'hamlit/parser/haml_compiler'
-require 'hamlit/parser/haml_error'
+# frozen_string_literal: true
 
 module Hamlit
   # This class encapsulates all of the configuration options that Haml
   # understands. Please see the {file:REFERENCE.md#options Haml Reference} to
   # learn how to set the options.
   class HamlOptions
-
-    @defaults = {
-      :attr_wrapper         => "'",
-      :autoclose            => %w(area base basefont br col command embed frame
-                                  hr img input isindex keygen link menuitem meta
-                                  param source track wbr),
-      :encoding             => "UTF-8",
-      :escape_attrs         => true,
-      :escape_html          => false,
-      :filename             => '(haml)',
-      :format               => :html5,
-      :hyphenate_data_attrs => true,
-      :line                 => 1,
-      :mime_type            => 'text/html',
-      :preserve             => %w(textarea pre code),
-      :remove_whitespace    => false,
-      :suppress_eval        => false,
-      :ugly                 => false,
-      :cdata                => false,
-      :parser_class         => ::Hamlit::HamlParser,
-      :compiler_class       => ::Hamlit::HamlCompiler,
-      :trace                => false
-    }
-
     @valid_formats = [:html4, :html5, :xhtml]
+    @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :format,
+      :encoding, :escape_html, :escape_filter_interpolations, :escape_attrs, :hyphenate_data_attrs, :cdata]
+
+    class << self
+      # The default option values.
+      # @return Hash
+      def defaults
+        @defaults ||= Hamlit::HamlTempleEngine.options.to_hash.merge(encoding: 'UTF-8')
+      end
 
-    @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :ugly, :format,
-      :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs, :cdata]
+      # An array of valid values for the `:format` option.
+      # @return Array
+      attr_reader :valid_formats
 
-    # The default option values.
-    # @return Hash
-    def self.defaults
-      @defaults
-    end
+      # An array of keys that will be used to provide a hash of options to
+      # {Hamlit::HamlBuffer}.
+      # @return Hash
+      attr_reader :buffer_option_keys
 
-    # An array of valid values for the `:format` option.
-    # @return Array
-    def self.valid_formats
-      @valid_formats
-    end
+      # Returns a subset of defaults: those that {Hamlit::HamlBuffer} cares about.
+      # @return [{Symbol => Object}] The options hash
+      def buffer_defaults
+        @buffer_defaults ||= buffer_option_keys.inject({}) do |hash, key|
+          hash.merge(key => defaults[key])
+        end
+      end
 
-    # An array of keys that will be used to provide a hash of options to
-    # {Haml::Buffer}.
-    # @return Hash
-    def self.buffer_option_keys
-      @buffer_option_keys
+      def wrap(options)
+        if options.is_a?(HamlOptions)
+          options
+        else
+          HamlOptions.new(options)
+        end
+      end
     end
 
     # The character that should wrap element attributes. This defaults to `'`
@@ -95,6 +82,13 @@ module Hamlit
     # Defaults to false.
     attr_accessor :escape_html
 
+    # Sets whether or not to escape HTML-sensitive characters in interpolated strings.
+    # See also {file:REFERENCE.md#escaping_html Escaping HTML} and
+    # {file:REFERENCE.md#unescaping_html Unescaping HTML}.
+    #
+    # Defaults to the current value of `escape_html`.
+    attr_accessor :escape_filter_interpolations
+
     # The name of the Haml file being parsed.
     # This is only used as information when exceptions are raised. This is
     # automatically assigned when working through ActionView, so it's really
@@ -128,7 +122,7 @@ module Hamlit
     attr_accessor :mime_type
 
     # A list of tag names that should automatically have their newlines
-    # preserved using the {Haml::Helpers#preserve} helper. This means that any
+    # preserved using the {Hamlit::HamlHelpers#preserve} helper. This means that any
     # content given on the same line as the tag will be preserved. For example,
     # `%textarea= "Foo\nBar"` compiles to `<textarea>Foo&#x000A;Bar</textarea>`.
     # Defaults to `['textarea', 'pre']`. See also
@@ -141,7 +135,7 @@ module Hamlit
     # formatting errors.
     #
     # Defaults to `false`.
-    attr_reader :remove_whitespace
+    attr_accessor :remove_whitespace
 
     # Whether or not attribute hashes and Ruby scripts designated by `=` or `~`
     # should be evaluated. If this is `true`, said scripts are rendered as empty
@@ -150,13 +144,6 @@ module Hamlit
     # Defaults to `false`.
     attr_accessor :suppress_eval
 
-    # If set to `true`, Haml makes no attempt to properly indent or format the
-    # HTML output. This significantly improves rendering performance but makes
-    # viewing the source unpleasant.
-    #
-    # Defaults to `true` in Rails production  mode, and `false` everywhere else.
-    attr_accessor :ugly
-
     # Whether to include CDATA sections around javascript and css blocks when
     # using the `:javascript` or `:css` filters.
     #
@@ -167,10 +154,10 @@ module Hamlit
     # xhtml.
     attr_accessor :cdata
 
-    # The parser class to use. Defaults to Haml::Parser.
+    # The parser class to use. Defaults to Hamlit::HamlParser.
     attr_accessor :parser_class
 
-    # The compiler class to use. Defaults to Haml::Compiler.
+    # The compiler class to use. Defaults to Hamlit::HamlCompiler.
     attr_accessor :compiler_class
 
     # Enable template tracing. If true, it will add a 'data-trace' attribute to
@@ -181,7 +168,10 @@ module Hamlit
     # the path will be the full path.
     attr_accessor :trace
 
-    def initialize(values = {}, &block)
+    # Key is filter name in String and value is Class to use. Defaults to {}.
+    attr_accessor :filters
+
+    def initialize(values = {})
       defaults.each {|k, v| instance_variable_set :"@#{k}", v}
       values.each {|k, v| send("#{k}=", v) if defaults.has_key?(k) && !v.nil?}
       yield if block_given?
@@ -200,8 +190,7 @@ module Hamlit
       send "#{key}=", value
     end
 
-    [:escape_attrs, :hyphenate_data_attrs, :remove_whitespace, :suppress_eval,
-      :ugly].each do |method|
+    [:escape_attrs, :hyphenate_data_attrs, :remove_whitespace, :suppress_eval].each do |method|
       class_eval(<<-END)
         def #{method}?
           !! @#{method}
@@ -242,7 +231,7 @@ module Hamlit
 
     def format=(value)
       unless self.class.valid_formats.include?(value)
-        raise ::Hamlit::HamlError, "Invalid output format #{value.inspect}"
+        raise Hamlit::HamlError, "Invalid output format #{value.inspect}"
       end
       @format = value
     end
@@ -252,18 +241,13 @@ module Hamlit
       xhtml? || @cdata
     end
 
-    def remove_whitespace=(value)
-      @ugly = true if value
-      @remove_whitespace = value
-    end
-
     def encoding=(value)
       return unless value
       @encoding = value.is_a?(Encoding) ? value.name : value.to_s
       @encoding = "UTF-8" if @encoding.upcase == "US-ASCII"
     end
 
-    # Returns a subset of options: those that {Haml::Buffer} cares about.
+    # Returns a non-default subset of options: those that {Hamlit::HamlBuffer} cares about.
     # All of the values here are such that when `#inspect` is called on the hash,
     # it can be `Kernel#eval`ed to get the same result back.
     #
@@ -272,7 +256,10 @@ module Hamlit
     # @return [{Symbol => Object}] The options hash
     def for_buffer
       self.class.buffer_option_keys.inject({}) do |hash, key|
-        hash[key] = send(key)
+        value = public_send(key)
+        if self.class.buffer_defaults[key] != value
+          hash[key] = value
+        end
         hash
       end
     end