haml 3.2.0.alpha.13 → 3.2.0.alpha.14

data/Rakefile

@@ -15,7 +15,7 @@ end
 
 desc "Benchmark Haml against ERb. TIMES=n sets the number of runs, default is 1000."
 task :benchmark do
-  sh "ruby test/benchmark.rb #{ENV['TIMES']}"
+  sh "ruby benchmark.rb #{ENV['TIMES']}"
 end
 
 Rake::TestTask.new do |t|

data/lib/haml/buffer.rb

@@ -16,7 +16,7 @@ module Haml
     # The options hash passed in from {Haml::Engine}.
     #
     # @return [{String => Object}]
-    # @see Haml::Engine#options_for_buffer
+    # @see Haml::Options#for_buffer
     attr_accessor :options
 
     # The {Buffer} for the enclosing Haml document.

data/lib/haml/compiler.rb

@@ -1,17 +1,58 @@
 require 'cgi'
 
 module Haml
-  module Compiler
+  class Compiler
     include Haml::Util
 
-    private
+    attr_accessor :options
+
+    def initialize(options)
+      @options     = options
+      @output_tabs = 0
+      @to_merge    = []
+      @precompiled = ''
+    end
+
+    def compile(node)
+      parent = instance_variable_defined?('@node') ? @node : nil
+      @node = node
+      if node.children.empty?
+        send(:"compile_#{node.type}")
+      else
+        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
+      end
+    ensure
+      @node = parent
+    end
+
+    if RUBY_VERSION < "1.9"
+      # The source code that is evaluated to produce the Haml document.
+      #
+      # In Ruby 1.9, this is automatically converted to the correct encoding
+      # (see {file:REFERENCE.md#encodings the `:encoding` option}).
+      #
+      # @return [String]
+      def precompiled
+        @precompiled
+      end
+    else
+      def precompiled
+        encoding = Encoding.find(@options[:encoding])
+        return @precompiled.force_encoding(encoding) if encoding == Encoding::BINARY
+        return @precompiled.encode(encoding)
+      end
+    end
+
+    def precompiled_with_return_value
+      precompiled + ";" + precompiled_method_return_value
+    end
 
     # Returns the precompiled string with the preamble and postamble
     def precompiled_with_ambles(local_names)
       preamble = <<END.gsub("\n", ";")
 begin
 extend Haml::Helpers
-_hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
+_hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options.for_buffer.inspect})
 _erbout = _hamlout.buffer
 END
       postamble = <<END.gsub("\n", ";")
@@ -23,6 +64,8 @@ END
       preamble + locals_code(local_names) + precompiled + postamble
     end
 
+    private
+
     # Returns the string used as the return value of the precompiled method.
     # This method exists so it can be monkeypatched to return modified values.
     def precompiled_method_return_value
@@ -154,10 +197,10 @@ END
         push_generated_script(
           "_hamlout.attributes(#{inspect_obj(t[:attributes])}, #{object_ref}#{attributes_hashes})")
         concat_merged_text(
-          if t[:self_closing] && xhtml?
+          if t[:self_closing] && @options.xhtml?
             " />" + (t[:nuke_outer_whitespace] ? "" : "\n")
           else
-            ">" + ((if t[:self_closing] && html?
+            ">" + ((if t[:self_closing] && @options.html?
                       t[:nuke_outer_whitespace]
                     else
                       !block_given? || t[:preserve_tag] || t[:nuke_inner_whitespace]
@@ -215,22 +258,27 @@ END
 
     def compile_filter
       unless filter = Filters.defined[@node.value[:name]]
-        raise Error.new("Filter \"#{@node.value[:name]}\" is not defined.", @node.line - 1)
+        name = @node.value[:name]
+        if ["maruku", "textile"].include?(name)
+          raise Error.new("To use the \"#{name}\" filter, please install the haml-contrib gem.", @node.line - 1)
+        else
+          raise Error.new("Filter \"#{name}\" is not defined.", @node.line - 1)
+        end
       end
       filter.internal_compile(self, @node.value[:text])
     end
 
     def text_for_doctype
       if @node.value[:type] == "xml"
-        return nil if html?
+        return nil if @options.html?
         wrapper = @options[:attr_wrapper]
         return "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{@node.value[:encoding] || "utf-8"}#{wrapper} ?>"
       end
 
-      if html5?
+      if @options.html5?
         '<!DOCTYPE html>'
       else
-        if xhtml?
+        if @options.xhtml?
           if @node.value[:version] == "1.1"
             '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
           elsif @node.value[:version] == "5"
@@ -246,7 +294,7 @@ END
             end
           end
 
-        elsif html4?
+        elsif @options.html4?
           case @node.value[:type]
           when "strict";   '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
           when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
@@ -260,7 +308,7 @@ END
     # does not output the result.
     def push_silent(text, can_suppress = false)
       flush_merged_text
-      return if can_suppress && options[:suppress_eval]
+      return if can_suppress && @options.suppress_eval?
       @precompiled << "#{resolve_newlines}#{text}\n"
       @output_line += text.count("\n") + 1
     end
@@ -321,7 +369,7 @@ END
     # If `opts[:preserve_script]` is true, Haml::Helpers#find_and_flatten is run on
     # the result before it is added to `@buffer`
     def push_script(text, opts = {})
-      return if options[:suppress_eval]
+      return if @options.suppress_eval?
 
       args = %w[preserve_script in_tag preserve_tag escape_html nuke_inner_whitespace]
       args.map! {|name| opts[name.to_sym]}
@@ -442,9 +490,10 @@ END
     end
 
     def prerender_tag(name, self_close, attributes)
+      # TODO: consider just passing in the damn options here
       attributes_string = Compiler.build_attributes(
-        html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
-      "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>"
+        @options.html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
+      "<#{name}#{attributes_string}#{self_close && @options.xhtml? ? ' /' : ''}>"
     end
 
     def resolve_newlines
@@ -478,17 +527,5 @@ END
         raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Compiler@to_merge.")
       end
     end
-
-    def compile(node)
-      parent = instance_variable_defined?('@node') ? @node : nil
-      @node = node
-      if node.children.empty?
-        send(:"compile_#{node.type}")
-      else
-        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
-      end
-    ensure
-      @node = parent
-    end
   end
 end

data/lib/haml/engine.rb

@@ -1,3 +1,6 @@
+require 'forwardable'
+
+require 'haml/options'
 require 'haml/helpers'
 require 'haml/buffer'
 require 'haml/parser'
@@ -16,13 +19,13 @@ module Haml
   #     output = haml_engine.render
   #     puts output
   class Engine
-    include Parser
-    include Compiler
+    extend Forwardable
+    include Haml::Util
 
-    # The options hash.
+    # The Haml::Options instance.
     # See {file:REFERENCE.md#options the Haml options documentation}.
     #
-    # @return [{Symbol => Object}]
+    # @return Haml::Options
     attr_accessor :options
 
     # The indentation used in the Haml document,
@@ -32,42 +35,14 @@ module Haml
     # @return [String]
     attr_accessor :indentation
 
-    # @return [Boolean] Whether or not the format is XHTML.
-    def xhtml?
-      not html?
-    end
-
-    # @return [Boolean] Whether or not the format is any flavor of HTML.
-    def html?
-      html4? or html5?
-    end
+    attr_accessor :compiler
+    attr_accessor :parser
 
-    # @return [Boolean] Whether or not the format is HTML4.
-    def html4?
-      @options[:format] == :html4
-    end
-
-    # @return [Boolean] Whether or not the format is HTML5.
-    def html5?
-      @options[:format] == :html5
-    end
+    # Tilt currently depends on these moved methods, provide a stable API
+    def_delegators :compiler, :precompiled, :precompiled_method_return_value
 
-    if RUBY_VERSION < "1.9"
-      # The source code that is evaluated to produce the Haml document.
-      #
-      # In Ruby 1.9, this is automatically converted to the correct encoding
-      # (see {file:REFERENCE.md#encodings the `:encoding` option}).
-      #
-      # @return [String]
-      def precompiled
-        @precompiled
-      end
-    else
-      def precompiled
-        encoding = Encoding.find(@options[:encoding])
-        return @precompiled.force_encoding(encoding) if encoding == Encoding::BINARY
-        return @precompiled.encode(encoding)
-      end
+    def options_for_buffer
+      @options.for_buffer
     end
 
     # Precompiles the Haml template.
@@ -77,57 +52,18 @@ module Haml
     #   see {file:REFERENCE.md#options the Haml options documentation}
     # @raise [Haml::Error] if there's a Haml syntax error in the template
     def initialize(template, options = {})
-      @options = {
-        :suppress_eval        => false,
-        :attr_wrapper         => "'",
-        # Don't forget to update the docs in doc-src/REFERENCE.md
-        # if you update these
-        :autoclose            => %w[meta img link br hr input area param col base],
-        :preserve             => %w[textarea pre code],
-        :filename             => '(haml)',
-        :line                 => 1,
-        :ugly                 => false,
-        :format               => :xhtml,
-        :escape_html          => false,
-        :escape_attrs         => true,
-        :hyphenate_data_attrs => true,
-      }
-
-      @index = nil # explicitily initialize to avoid warnings
+      @options = Options.new(options)
 
-      template = check_haml_encoding(template) do |msg, line|
+      @template = check_haml_encoding(template) do |msg, line|
         raise Haml::Error.new(msg, line)
       end
 
-      set_up_encoding(options, template)
+      initialize_encoding options[:encoding]
 
-      @options.merge! options.reject {|k, v| v.nil?}
-      @index = 0
+      @parser   = Parser.new(@template, @options)
+      @compiler = Compiler.new(@options)
 
-      @options[:format] = :xhtml if @options[:mime_type] == 'text/xml'
-
-      unless [:xhtml, :html4, :html5].include?(@options[:format])
-        raise Haml::Error, "Invalid output format #{@options[:format].inspect}"
-      end
-
-      # :eod is a special end-of-document marker
-      @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
-      @template_index = 0
-      @to_close_stack = []
-      @output_tabs = 0
-      @template_tabs = 0
-      @flat = false
-      @newlines = 0
-      @precompiled = ''
-      @to_merge = []
-      @tab_change  = 0
-
-      compile(parse)
-    rescue Haml::Error => e
-      if @index || e.line
-        e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}"
-      end
-      raise
+      @compiler.compile(@parser.parse)
     end
 
     # Processes the template and returns the result as a string.
@@ -173,7 +109,7 @@ module Haml
     # @return [String] The rendered template
     def render(scope = Object.new, locals = {}, &block)
       parent = scope.instance_variable_defined?('@haml_buffer') ? scope.instance_variable_get('@haml_buffer') : nil
-      buffer = Haml::Buffer.new(parent, options_for_buffer)
+      buffer = Haml::Buffer.new(parent, @options.for_buffer)
 
       if scope.is_a?(Binding) || scope.is_a?(Proc)
         scope_object = eval("self", scope)
@@ -190,8 +126,7 @@ module Haml
         @haml_buffer = buffer
       end
 
-      eval(precompiled + ";" + precompiled_method_return_value,
-        scope, @options[:filename], @options[:line])
+      eval(@compiler.precompiled_with_return_value, scope, @options[:filename], @options[:line])
     ensure
       # Get rid of the current buffer
       scope_object.instance_eval do
@@ -233,7 +168,7 @@ module Haml
       end
 
       eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
-           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
+           compiler.precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
     end
 
     # Defines a method on `object` with the given name
@@ -277,45 +212,19 @@ module Haml
     def def_method(object, name, *local_names)
       method = object.is_a?(Module) ? :module_eval : :instance_eval
 
-      object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end",
+      object.send(method, "def #{name}(_haml_locals = {}); #{compiler.precompiled_with_ambles(local_names)}; end",
                   @options[:filename], @options[:line])
     end
 
-    protected
-
-    # Returns a subset of \{#options}: those that {Haml::Buffer} 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.
-    #
-    # See {file:REFERENCE.md#options the Haml options documentation}.
-    #
-    # @return [{Symbol => Object}] The options hash
-    def options_for_buffer
-      {
-        :autoclose            => @options[:autoclose],
-        :preserve             => @options[:preserve],
-        :attr_wrapper         => @options[:attr_wrapper],
-        :ugly                 => @options[:ugly],
-        :format               => @options[:format],
-        :encoding             => @options[:encoding],
-        :escape_html          => @options[:escape_html],
-        :escape_attrs         => @options[:escape_attrs],
-        :hyphenate_data_attrs => @options[:hyphenate_data_attrs],
-      }
-    end
-
     private
 
     if RUBY_VERSION < "1.9"
-      def set_up_encoding(options, template)
-        options
+      def initialize_encoding(given_value)
       end
     else
-      def set_up_encoding(options, template)
-        @options.tap do |ops|
-          ops[:encoding] = Encoding.default_internal || template.encoding
-          ops[:encoding] = "utf-8" if ops[:encoding].name == "US-ASCII"
-          ops[:encoding] = ops[:encoding].name if ops[:encoding].is_a?(Encoding)
+      def initialize_encoding(given_value)
+        unless given_value
+          @options.encoding = Encoding.default_internal || @template.encoding
         end
       end
     end

data/lib/haml/exec.rb

@@ -298,82 +298,5 @@ END
         output.close() if output.is_a? File
       end
     end
-
-    # The `html2haml` executable.
-    class HTML2Haml < Generic
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @module_opts = {}
-      end
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: html2haml [options] [INPUT] [OUTPUT]
-
-Description: Transforms an HTML file into corresponding Haml code.
-
-Options:
-END
-
-        opts.on('-e', '--erb', 'Parse ERb tags.') do
-          @module_opts[:erb] = true
-        end
-
-        opts.on('--no-erb', "Don't parse ERb tags.") do
-          @options[:no_erb] = true
-        end
-
-        opts.on('-r', '--rhtml', 'Deprecated; same as --erb.') do
-          @module_opts[:erb] = true
-        end
-
-        opts.on('--no-rhtml', "Deprecated; same as --no-erb.") do
-          @options[:no_erb] = true
-        end
-
-        opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
-          @module_opts[:xhtml] = true
-        end
-
-        opts.on("--html-attributes", "Use HTML style attributes instead of Ruby hash style.") do
-          @module_opts[:html_style_attributes] = true
-        end
-
-        unless RUBY_VERSION < "1.9"
-          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
-
-        super
-      end
-
-      # Processes the options set by the command-line arguments,
-      # and runs the HTML compiler appropriately.
-      def process_result
-        super
-
-        require 'haml/html'
-
-        input = @options[:input]
-        output = @options[:output]
-
-        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:erb] &&= @options[:no_erb] != false
-
-        output.write(::Haml::HTML.new(input, @module_opts).render)
-      rescue ::Haml::Error => e
-        raise "#{e.is_a?(::Haml::SyntaxError) ? "Syntax error" : "Error"} on line " +
-          "#{get_line e}: #{e.message}"
-      rescue LoadError => err
-        handle_load_error(err)
-      end
-    end
   end
 end