haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/init.rb

@@ -1,18 +1 @@
-begin
-  require File.join(File.dirname(__FILE__), 'lib', 'haml') # From here
-rescue LoadError
-  begin
-    require 'haml' # From gem
-  rescue LoadError => e
-    # gems:install may be run to install Haml with the skeleton plugin
-    # but not the gem itself installed.
-    # Don't die if this is the case.
-    raise e unless defined?(Rake) &&
-      (Rake.application.top_level_tasks.include?('gems') ||
-        Rake.application.top_level_tasks.include?('gems:install'))
-  end
-end
-
-# Load Haml.
-# Haml may be undefined if we're running gems:install.
-Haml.init_rails(binding) if defined?(Haml)
+require "haml"

data/lib/haml.rb

@@ -1,6 +1,3 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
 require 'haml/version'
 
 # The module that contains everything Haml-related:
@@ -11,37 +8,16 @@ require 'haml/version'
 # * {Haml::Error} is raised when Haml encounters an error.
 # * {Haml::HTML} handles conversion of HTML to Haml.
 #
-# Also see the {file:HAML_REFERENCE.md full Haml reference}.
+# Also see the {file:REFERENCE.md full Haml reference}.
 module Haml
-  # Initializes Haml for Rails.
-  #
-  # This method is called by `init.rb`,
-  # which is run by Rails on startup.
-  # We use it rather than putting stuff straight into `init.rb`
-  # so we can change the initialization behavior
-  # without modifying the file itself.
-  #
-  # @param binding [Binding] The context of the `init.rb` file.
-  #   This isn't actually used;
-  #   it's just passed in in case it needs to be used in the future
-  def self.init_rails(binding)
-    # 2.2 <= Rails < 3
-    if defined?(Rails) && Rails.respond_to?(:configuration) &&
-        Rails.configuration.respond_to?(:after_initialize) &&
-        !Haml::Util.ap_geq_3?
-      Rails.configuration.after_initialize do
-        next if defined?(Sass)
-        autoload(:Sass, 'sass/rails2_shim')
-        # resolve autoload if it looks like they're using Sass without options
-        Sass if File.exist?(File.join(RAILS_ROOT, 'public/stylesheets/sass'))
-      end
-    end
 
-    # No &method here for Rails 2.1 compatibility
-    %w[haml/template].each {|f| require f}
+  def self.init_rails(*args)
+    # Maintain this as a no-op for any libraries that may be depending on the
+    # previous definition here.
   end
+
 end
 
 require 'haml/util'
 require 'haml/engine'
-require 'haml/railtie'
+require 'haml/railtie' if defined?(Rails)

data/lib/haml/buffer.rb

@@ -88,15 +88,17 @@ module Haml
     # @param options [{Symbol => Object}] An options hash.
     #   See {Haml::Engine#options\_for\_buffer}
     def initialize(upper = nil, options = {})
-      @active = true
-      @upper = upper
-      @options = options
-      @buffer = ruby1_8? ? "" : "".encode(Encoding.find(options[:encoding]))
+      @active     = true
+      @upper      = upper
+      @options    = options
+      @buffer     = new_encoded_string
       @tabulation = 0
 
       # The number of tabs that Engine thinks we should have
       # @real_tabs + @tabulation is the number of tabs actually output
       @real_tabs = 0
+
+      @preserve_pattern = /<[\s]*#{@options[:preserve].join("|")}/i
     end
 
     # Appends text to the buffer, properly tabulated.
@@ -141,7 +143,9 @@ module Haml
           @tabulation = 0
         <% end %>
 
+        <% if !(in_tag && preserve_tag && !nuke_inner_whitespace) %>
         tabulation = @real_tabs
+        <% end %>
         result = <%= result_name %>.<% if nuke_inner_whitespace %>strip<% else %>rstrip<% end %>
       <% else %>
         result = <%= result_name %><% if nuke_inner_whitespace %>.strip<% end %>
@@ -157,7 +161,12 @@ module Haml
         return result
       <% else %>
 
-        has_newline = result.include?("\\n") 
+        return result if self.instance_variable_get(:@preserve_pattern).match(result)
+
+        <% if !(in_tag && preserve_tag && !nuke_inner_whitespace) %>
+        has_newline = result.include?("\\n")
+        <% end %>
+
         <% if in_tag && !nuke_inner_whitespace %>
           <% unless preserve_tag %> if !has_newline <% end %>
           @real_tabs -= 1
@@ -166,6 +175,7 @@ module Haml
           <% unless preserve_tag %> end <% end %>
         <% end %>
 
+        <% if !(in_tag && preserve_tag && !nuke_inner_whitespace) %>
         # Precompiled tabulation may be wrong
         <% if !interpolated && !in_tag %>
           result = tabs + result if @tabulation > 0
@@ -184,17 +194,18 @@ module Haml
         <% end %>
         <% if interpolated %> @tabulation = old_tabulation <% end %>
         result
+        <% end %>
       <% end %>
 RUBY
 
     def attributes(class_id, obj_ref, *attributes_hashes)
       attributes = class_id
       attributes_hashes.each do |old|
-        self.class.merge_attrs(attributes, to_hash(old.map {|k, v| [k.to_s, v]}))
+        self.class.merge_attrs(attributes, Hash[old.map {|k, v| [k.to_s, v]}])
       end
       self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
       Compiler.build_attributes(
-        html?, @options[:attr_wrapper], @options[:escape_attrs], attributes)
+        html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
     end
 
     # Remove the whitespace from the right side of the buffer string.
@@ -237,21 +248,31 @@ RUBY
         from['class'] ||= to['class']
       end
 
-      from_data = from['data'].is_a?(Hash)
-      to_data = to['data'].is_a?(Hash)
-      if from_data && to_data
-        to['data'] = to['data'].merge(from['data'])
-      elsif to_data
-        to = Haml::Util.map_keys(to.delete('data')) {|name| "data-#{name}"}.merge(to)
-      elsif from_data
-        from = Haml::Util.map_keys(from.delete('data')) {|name| "data-#{name}"}.merge(from)
-      end
+      from_data = from.delete('data') || {}
+      to_data = to.delete('data') || {}
 
+      # forces to_data & from_data into a hash
+      from_data = { nil => from_data } unless from_data.is_a?(Hash)
+      to_data = { nil => to_data } unless to_data.is_a?(Hash)
+
+      merged_data = to_data.merge(from_data)
+
+      to['data'] = merged_data unless merged_data.empty?
       to.merge!(from)
     end
 
     private
 
+    if RUBY_VERSION < "1.9"
+      def new_encoded_string
+        ""
+      end
+    else
+      def new_encoded_string
+        "".encode(Encoding.find(options[:encoding]))
+      end
+    end
+
     @@tab_cache = {}
     # Gets `count` tabs. Mostly for internal use.
     def tabs(count = 0)

data/lib/haml/compiler.rb

@@ -11,9 +11,8 @@ module Haml
       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
-__in_erb_template = true
 END
       postamble = <<END.gsub("\n", ";")
 #{precompiled_method_return_value}
@@ -53,17 +52,28 @@ END
       push_text @node.value[:text]
     end
 
+    def nuke_inner_whitespace?(node)
+      if node.value && node.value[:nuke_inner_whitespace]
+        true
+      elsif node.parent
+        nuke_inner_whitespace?(node.parent)
+      else
+        false
+      end
+    end
+
     def compile_script(&block)
       push_script(@node.value[:text],
-        :preserve_script => @node.value[:preserve],
-        :escape_html => @node.value[:escape_html], &block)
+                  :preserve_script       => @node.value[:preserve],
+                  :escape_html           => @node.value[:escape_html],
+                  :nuke_inner_whitespace => nuke_inner_whitespace?(@node),
+                  &block)
     end
 
     def compile_silent_script
       return if @options[:suppress_eval]
       push_silent(@node.value[:text])
       keyword = @node.value[:keyword]
-      ruby_block = block_given? && !keyword
 
       if block_given?
         # Store these values because for conditional statements,
@@ -345,14 +355,18 @@ END
     end
 
     # This is a class method so it can be accessed from Buffer.
-    def self.build_attributes(is_html, attr_wrapper, escape_attrs, attributes = {})
-      quote_escape = attr_wrapper == '"' ? "&quot;" : "&apos;"
+    def self.build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes = {})
+      # @TODO this is an absolutely ridiculous amount of arguments. At least
+      # some of this needs to be moved into an instance method.
+      quote_escape     = attr_wrapper == '"' ? "&#x0022;" : "&#x0027;"
       other_quote_char = attr_wrapper == '"' ? "'" : '"'
+      join_char        = hyphenate_data_attrs ? '-' : '_'
 
       if attributes['data'].is_a?(Hash)
-        attributes = attributes.dup
-        attributes =
-          Haml::Util.map_keys(attributes.delete('data')) {|name| "data-#{name}"}.merge(attributes)
+        data_attributes = attributes.delete('data')
+        data_attributes = flatten_data_attributes(data_attributes, '', join_char)
+        data_attributes = build_data_keys(data_attributes, hyphenate_data_attrs)
+        attributes = data_attributes.merge(attributes)
       end
 
       result = attributes.collect do |attr, value|
@@ -379,7 +393,7 @@ END
         value = Haml::Helpers.preserve(escaped)
         if escape_attrs
           # We want to decide whether or not to escape quotes
-          value = value.gsub('&quot;', '"')
+          value = value.gsub('&quot;', '"').gsub('&#x0022;', '"')
           this_attr_wrapper = attr_wrapper
           if value.include? attr_wrapper
             if value.include? other_quote_char
@@ -403,9 +417,33 @@ END
       return !value.empty? && value
     end
 
+    def self.build_data_keys(data_hash, hyphenate)
+      Hash[data_hash.map do |name, value|
+        if name == nil
+          ["data", value]
+        elsif hyphenate
+          ["data-#{name.to_s.gsub(/_/, '-')}", value]
+        else
+          ["data-#{name}", value]
+        end
+      end]
+    end
+
+    def self.flatten_data_attributes(data, key, join_char, seen = [])
+      return {key => nil} if seen.include? data.object_id
+      seen << data.object_id
+
+      return {key => data} unless data.is_a?(Hash)
+      data.sort {|x, y| x[0].to_s <=> y[0].to_s}.inject({}) do |hash, array|
+        k, v = array
+        joined = key == '' ? k : [key, k].join(join_char)
+        hash.merge! flatten_data_attributes(v, joined, join_char, seen)
+      end
+    end
+
     def prerender_tag(name, self_close, attributes)
       attributes_string = Compiler.build_attributes(
-        html?, @options[:attr_wrapper], @options[:escape_attrs], attributes)
+        html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
       "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>"
     end
 
@@ -442,7 +480,8 @@ END
     end
 
     def compile(node)
-      parent, @node = @node, node
+      parent = instance_variable_defined?('@node') ? @node : nil
+      @node = node
       if node.children.empty?
         send(:"compile_#{node.type}")
       else

data/lib/haml/engine.rb

@@ -20,7 +20,7 @@ module Haml
     include Compiler
 
     # The options hash.
-    # See {file:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+    # See {file:REFERENCE.md#options the Haml options documentation}.
     #
     # @return [{Symbol => Object}]
     attr_accessor :options
@@ -52,63 +52,64 @@ module Haml
       @options[:format] == :html5
     end
 
-    # 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:HAML_REFERENCE.md#encoding-option the `:encoding` option}).
-    #
-    # @return [String]
-    def precompiled
-      return @precompiled if ruby1_8?
-      encoding = Encoding.find(@options[:encoding])
-      return @precompiled.force_encoding(encoding) if encoding == Encoding::BINARY
-      return @precompiled.encode(encoding)
+    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
 
     # Precompiles the Haml template.
     #
     # @param template [String] The Haml template
     # @param options [{Symbol => Object}] An options hash;
-    #   see {file:HAML_REFERENCE.md#haml_options the Haml options documentation}
+    #   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/HAML_REFERENCE.md
+        :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,
+        :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
 
       template = check_haml_encoding(template) do |msg, line|
         raise Haml::Error.new(msg, line)
       end
 
-      unless ruby1_8?
-        @options[:encoding] = Encoding.default_internal || template.encoding
-        @options[:encoding] = "utf-8" if @options[:encoding].name == "US-ASCII"
-      end
+      set_up_encoding(options, template)
+
       @options.merge! options.reject {|k, v| v.nil?}
       @index = 0
 
+      @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
 
-      if @options[:encoding] && @options[:encoding].is_a?(Encoding)
-        @options[:encoding] = @options[:encoding].name
-      end
-
       # :eod is a special end-of-document marker
       @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
       @template_index = 0
@@ -171,7 +172,8 @@ module Haml
     # @param block [#to_proc] A block that can be yielded to within the template
     # @return [String] The rendered template
     def render(scope = Object.new, locals = {}, &block)
-      buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
+      parent = scope.instance_variable_defined?('@haml_buffer') ? scope.instance_variable_get('@haml_buffer') : nil
+      buffer = Haml::Buffer.new(parent, options_for_buffer)
 
       if scope.is_a?(Binding) || scope.is_a?(Proc)
         scope_object = eval("self", scope)
@@ -285,24 +287,39 @@ module Haml
     # 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:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+    # 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],
+        :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
+      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)
+        end
+      end
+    end
+
     def set_locals(locals, scope, scope_object)
       scope_object.send(:instance_variable_set, '@_haml_locals', locals)
       set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")