haml 2.0.10 → 2.2.0

data/lib/haml/helpers/action_view_extensions.rb

@@ -1,45 +1,40 @@
 require 'haml/helpers/action_view_mods'
 
-if defined?(ActionView)
-  module Haml
-    module Helpers
-      # This module contains various useful helper methods
-      # that either tie into ActionView or the rest of the ActionPack stack,
-      # or are only useful in that context.
-      # Thus, the methods defined here are only available
-      # if ActionView is installed.
-      module ActionViewExtensions
-        # Returns a value for the "class" attribute
-        # unique to this controller/action pair.
-        # This can be used to target styles specifically at this action or controller.
-        # For example, if the current action were EntryController#show,
-        #
-        #   %div{:class => page_class} My Div
-        #
-        # would become
-        #
-        #   <div class="entry show">My Div</div>
-        #
-        # Then, in a stylesheet
-        # (shown here as Sass),
-        # you could refer to this specific action:
-        #
-        #   .entry.show
-        #     :font-weight bold
-        #
-        # or to all actions in the entry controller:
-        #
-        #   .entry
-        #     :color #00f
-        #
-        def page_class
-          controller.controller_name + " " + controller.action_name
-        end
-
-        # :stopdoc:
-        alias_method :generate_content_class_names, :page_class
-        # :startdoc:
+module Haml
+  module Helpers
+    # This module contains various useful helper methods
+    # that either tie into ActionView or the rest of the ActionPack stack,
+    # or are only useful in that context.
+    # Thus, the methods defined here are only available
+    # if ActionView is installed.
+    module ActionViewExtensions
+      # Returns a value for the "class" attribute
+      # unique to this controller/action pair.
+      # This can be used to target styles specifically at this action or controller.
+      # For example, if the current action were `EntryController#show`,
+      #
+      #     %div{:class => page_class} My Div
+      #
+      # would become
+      #
+      #     <div class="entry show">My Div</div>
+      #
+      # Then, in a stylesheet (shown here as {Sass}),
+      # you could refer to this specific action:
+      #
+      #     .entry.show
+      #       font-weight: bold
+      #
+      # or to all actions in the entry controller:
+      #
+      #     .entry
+      #       color: #00f
+      #
+      # @return [String] The class name for the current page
+      def page_class
+        controller.controller_name + " " + controller.action_name
       end
+      alias_method :generate_content_class_names, :page_class
     end
   end
 end

data/lib/haml/helpers/action_view_mods.rb

@@ -1,166 +1,139 @@
-if defined?(ActionView) and not defined?(Merb::Plugins)
-  module ActionView
-    class Base # :nodoc:
-      def render_with_haml(*args, &block)
-        options = args.first
-
-        # If render :layout is used with a block,
-        # it concats rather than returning a string
-        # so we need it to keep thinking it's Haml
-        # until it hits the sub-render
-        if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
-          return non_haml { render_without_haml(*args, &block) }
-        end
-        render_without_haml(*args, &block)
+module ActionView
+  class Base
+    def render_with_haml(*args, &block)
+      options = args.first
+
+      # If render :layout is used with a block,
+      # it concats rather than returning a string
+      # so we need it to keep thinking it's Haml
+      # until it hits the sub-render
+      if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
+        return non_haml { render_without_haml(*args, &block) }
+      end
+      render_without_haml(*args, &block)
+    end
+    alias_method :render_without_haml, :render
+    alias_method :render, :render_with_haml
+
+    # Rails >2.1
+    if Haml::Util.has?(:instance_method, self, :output_buffer)
+      def output_buffer_with_haml
+        return haml_buffer.buffer if is_haml?
+        output_buffer_without_haml
       end
-      alias_method :render_without_haml, :render
-      alias_method :render, :render_with_haml
-
-      # Rails >2.1
-      if Haml::Util.has?(:instance_method, self, :output_buffer)
-        def output_buffer_with_haml
-          return haml_buffer.buffer if is_haml?
-          output_buffer_without_haml
+      alias_method :output_buffer_without_haml, :output_buffer
+      alias_method :output_buffer, :output_buffer_with_haml
+
+      def set_output_buffer_with_haml(new)
+        if is_haml?
+          haml_buffer.buffer = new
+        else
+          set_output_buffer_without_haml new
         end
-        alias_method :output_buffer_without_haml, :output_buffer
-        alias_method :output_buffer, :output_buffer_with_haml
+      end
+      alias_method :set_output_buffer_without_haml, :output_buffer=
+      alias_method :output_buffer=, :set_output_buffer_with_haml
+    end
+  end
 
-        def set_output_buffer_with_haml(new)
-          if is_haml?
-            haml_buffer.buffer = new
+  module Helpers
+    # In Rails <=2.1, we've got to override considerable capturing infrastructure.
+    # In Rails >2.1, we can make do with only overriding #capture
+    # (which no longer behaves differently in helper contexts).
+    unless Haml::Util.has?(:instance_method, ActionView::Base, :output_buffer)
+      module CaptureHelper
+        def capture_with_haml(*args, &block)
+          # Rails' #capture helper will just return the value of the block
+          # if it's not actually in the template context,
+          # as detected by the existance of an _erbout variable.
+          # We've got to do the same thing for compatibility.
+
+          if is_haml? && block_is_haml?(block)
+            capture_haml(*args, &block)
           else
-            set_output_buffer_without_haml new
+            capture_without_haml(*args, &block)
           end
         end
-        alias_method :set_output_buffer_without_haml, :output_buffer=
-        alias_method :output_buffer=, :set_output_buffer_with_haml
-      end
-    end
+        alias_method :capture_without_haml, :capture
+        alias_method :capture, :capture_with_haml
 
-    # This overrides various helpers in ActionView
-    # to make them work more effectively with Haml.
-    module Helpers
-      # :stopdoc:
-      # In Rails <=2.1, we've got to override considerable capturing infrastructure.
-      # In Rails >2.1, we can make do with only overriding #capture
-      # (which no longer behaves differently in helper contexts).
-      unless Haml::Util.has?(:instance_method, ActionView::Base, :output_buffer)
-        module CaptureHelper
-          def capture_with_haml(*args, &block)
-            # Rails' #capture helper will just return the value of the block
-            # if it's not actually in the template context,
-            # as detected by the existance of an _erbout variable.
-            # We've got to do the same thing for compatibility.
-
-            if is_haml? && block_is_haml?(block)
-              capture_haml(*args, &block)
-            else
-              capture_without_haml(*args, &block)
-            end
-          end
-          alias_method :capture_without_haml, :capture
-          alias_method :capture, :capture_with_haml
-
-          def capture_erb_with_buffer_with_haml(buffer, *args, &block)
-            if is_haml?
-              capture_haml(*args, &block)
-            else
-              capture_erb_with_buffer_without_haml(buffer, *args, &block)
-            end
+        def capture_erb_with_buffer_with_haml(buffer, *args, &block)
+          if is_haml?
+            capture_haml(*args, &block)
+          else
+            capture_erb_with_buffer_without_haml(buffer, *args, &block)
           end
-          alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
-          alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
         end
+        alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
+        alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
+      end
 
-        module TextHelper
-          def concat_with_haml(string, binding = nil)
-            if is_haml?
-              haml_buffer.buffer.concat(string)
-            else
-              concat_without_haml(string, binding)
-            end
+      module TextHelper
+        def concat_with_haml(string, binding = nil)
+          if is_haml?
+            haml_buffer.buffer.concat(string)
+          else
+            concat_without_haml(string, binding)
           end
-          alias_method :concat_without_haml, :concat
-          alias_method :concat, :concat_with_haml
         end
-      else
-        module CaptureHelper
-          def capture_with_haml(*args, &block)
-            if Haml::Helpers.block_is_haml?(block)
-              capture_haml(*args, &block)
-            else
-              capture_without_haml(*args, &block)
-            end
+        alias_method :concat_without_haml, :concat
+        alias_method :concat, :concat_with_haml
+      end
+    else
+      module CaptureHelper
+        def capture_with_haml(*args, &block)
+          if Haml::Helpers.block_is_haml?(block)
+            capture_haml(*args, &block)
+          else
+            capture_without_haml(*args, &block)
           end
-          alias_method :capture_without_haml, :capture
-          alias_method :capture, :capture_with_haml
         end
+        alias_method :capture_without_haml, :capture
+        alias_method :capture, :capture_with_haml
       end
+    end
 
-      module TagHelper
-        def content_tag_with_haml(name, *args, &block)
-          return content_tag_without_haml(name, *args, &block) unless is_haml?
+    module TagHelper
+      def content_tag_with_haml(name, *args, &block)
+        return content_tag_without_haml(name, *args, &block) unless is_haml?
 
-          preserve = haml_buffer.options[:preserve].include?(name.to_s)
+        preserve = haml_buffer.options[:preserve].include?(name.to_s)
 
-          if block_given? && block_is_haml?(block) && preserve
-            return content_tag_without_haml(name, *args) {preserve(&block)}
-          end
-
-          returning content_tag_without_haml(name, *args, &block) do |content|
-            return Haml::Helpers.preserve(content) if preserve && content
-          end
+        if block_given? && block_is_haml?(block) && preserve
+          return content_tag_without_haml(name, *args) {preserve(&block)}
         end
 
-        alias_method :content_tag_without_haml, :content_tag
-        alias_method :content_tag, :content_tag_with_haml
+        returning content_tag_without_haml(name, *args, &block) do |content|
+          return Haml::Helpers.preserve(content) if preserve && content
+        end
       end
 
-      class InstanceTag
-        # Includes TagHelper
+      alias_method :content_tag_without_haml, :content_tag
+      alias_method :content_tag, :content_tag_with_haml
+    end
 
-        def haml_buffer
-          @template_object.send :haml_buffer
-        end
+    class InstanceTag
+      # Includes TagHelper
 
-        def is_haml?
-          @template_object.send :is_haml?
-        end
-
-        alias_method :content_tag_without_haml, :content_tag
-        alias_method :content_tag, :content_tag_with_haml
+      def haml_buffer
+        @template_object.send :haml_buffer
       end
 
-      module FormTagHelper
-        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if is_haml?
-            if block_given?
-              oldproc = proc
-              proc = haml_bind_proc do |*args|
-                concat "\n"
-                tab_up
-                oldproc.call(*args)
-                tab_down
-                concat haml_indent
-              end
-              concat haml_indent
-            end
-            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-            concat "\n" if block_given?
-            res
-          else
-            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-          end
-        end
-        alias_method :form_tag_without_haml, :form_tag
-        alias_method :form_tag, :form_tag_with_haml
+      def is_haml?
+        @template_object.send :is_haml?
       end
 
-      module FormHelper
-        def form_for_with_haml(object_name, *args, &proc)
-          if block_given? && is_haml?
+      alias_method :content_tag_without_haml, :content_tag
+      alias_method :content_tag, :content_tag_with_haml
+    end
+
+    module FormTagHelper
+      def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
+        if is_haml?
+          if block_given?
             oldproc = proc
             proc = haml_bind_proc do |*args|
+              concat "\n"
               tab_up
               oldproc.call(*args)
               tab_down
@@ -168,14 +141,34 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
             end
             concat haml_indent
           end
-          form_for_without_haml(object_name, *args, &proc)
-          concat "\n" if block_given? && is_haml?
+          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
+          concat "\n" if block_given?
+          res
+        else
+          form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
         end
-        alias_method :form_for_without_haml, :form_for
-        alias_method :form_for, :form_for_with_haml
       end
-      # :startdoc:
+      alias_method :form_tag_without_haml, :form_tag
+      alias_method :form_tag, :form_tag_with_haml
+    end
+
+    module FormHelper
+      def form_for_with_haml(object_name, *args, &proc)
+        if block_given? && is_haml?
+          oldproc = proc
+          proc = haml_bind_proc do |*args|
+            tab_up
+            oldproc.call(*args)
+            tab_down
+            concat haml_indent
+          end
+          concat haml_indent
+        end
+        form_for_without_haml(object_name, *args, &proc)
+        concat "\n" if block_given? && is_haml?
+      end
+      alias_method :form_for_without_haml, :form_for
+      alias_method :form_for, :form_for_with_haml
     end
   end
 end
-

data/lib/haml/html.rb

@@ -6,15 +6,21 @@ require 'hpricot'
 require 'cgi'
 
 module Haml
-  # This class contains the functionality used in the +html2haml+ utility,
-  # namely converting HTML documents to Haml templates.
-  # It depends on Hpricot for HTML parsing (http://code.whytheluckystiff.net/hpricot/).
+  # Converts HTML documents into Haml templates.
+  # Depends on [Hpricot](http://code.whytheluckystiff.net/hpricot/) for HTML parsing.
+  #
+  # Example usage:
+  #
+  #     Haml::Engine.new("<a href='http://google.com'>Blat</a>").render
+  #       #=> "%a{:href => 'http://google.com'} Blat"
   class HTML
-    # Creates a new instance of Haml::HTML that will compile the given template,
-    # which can either be a string containing HTML or an Hpricot node,
-    # to a Haml string when +render+ is called.
+    # @param template [String, Hpricot::Node] The HTML template to convert
+    # @option options :rhtml [Boolean] (false) Whether or not to parse
+    #   ERB's `<%= %>` and `<% %>` into Haml's `=` and `-`
+    # @option options :xhtml [Boolean] (false) Whether or not to parse
+    #   the HTML strictly as XHTML
     def initialize(template, options = {})
-      @@options = options
+      @options = options
 
       if template.is_a? Hpricot::Node
         @template = template
@@ -23,12 +29,12 @@ module Haml
           template = template.read
         end
 
-        if @@options[:rhtml]
+        if @options[:rhtml]
           match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
           match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
         end
 
-        method = @@options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
+        method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
         @template = method.call(template.gsub('&', '&amp;'))
       end
     end
@@ -36,14 +42,18 @@ module Haml
     # Processes the document and returns the result as a string
     # containing the Haml template.
     def render
-      @template.to_haml(0)
+      @template.to_haml(0, @options)
     end
     alias_method :to_haml, :render
 
+    # Haml monkeypatches various Hpricot classes
+    # to add methods for conversion to Haml.
     module ::Hpricot::Node
-      # Returns the Haml representation of the given node,
-      # at the given tabulation.
-      def to_haml(tabs = 0)
+      # 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)
         parse_text(self.to_s, tabs)
       end
 
@@ -68,34 +78,36 @@ module Haml
       end
     end
 
-    # :stopdoc:
-
-    def self.options
-      @@options
-    end
-
     TEXT_REGEXP = /^(\s*).*$/
 
+    # @see Hpricot::Node
     class ::Hpricot::Doc
-      def to_haml(tabs = 0)
-        (children || []).inject('') {|s, c| s << c.to_haml(0)}
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
+        (children || []).inject('') {|s, c| s << c.to_haml(0, options)}
       end
     end
 
+    # @see Hpricot::Node
     class ::Hpricot::XMLDecl
-      def to_haml(tabs = 0)
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
         "#{tabulate(tabs)}!!! XML\n"
       end
     end
 
+    # @see Hpricot::Node
     class ::Hpricot::CData
-      def to_haml(tabs = 0)
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
         "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
+    # @see Hpricot::Node
     class ::Hpricot::DocType
-      def to_haml(tabs = 0)
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
         attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
         if attrs == nil
           raise Exception.new("Invalid doctype")
@@ -125,35 +137,40 @@ module Haml
       end
     end
 
+    # @see Hpricot::Node
     class ::Hpricot::Comment
-      def to_haml(tabs = 0)
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
         "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
+    # @see Hpricot::Node
     class ::Hpricot::Elem
-      def to_haml(tabs = 0)
+      # @see Hpricot::Node#to_haml
+      def to_haml(tabs, options)
         output = "#{tabulate(tabs)}"
-        if HTML.options[:rhtml] && name[0...5] == 'haml:'
-          return output + HTML.send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
+        if options[:rhtml] && name[0...5] == 'haml:'
+          return output + send("haml_tag_#{name[5..-1]}", CGI.unescapeHTML(self.inner_text))
         end
 
-        output += "%#{name}" unless name == 'div' && (static_id? || static_classname?)
+        output += "%#{name}" unless name == 'div' &&
+          (static_id?(options) || static_classname?(options))
 
         if attributes
-          if static_id?
+          if static_id?(options)
             output += "##{attributes['id']}"
             remove_attribute('id')
           end
-          if static_classname?
+          if static_classname?(options)
             attributes['class'].split(' ').each { |c| output += ".#{c}" }
             remove_attribute('class')
           end
-          output += haml_attributes if attributes.length > 0
+          output += haml_attributes(options) if attributes.length > 0
         end
 
         (self.children || []).inject(output + "\n") do |output, child|
-          output + child.to_haml(tabs + 1)
+          output + child.to_haml(tabs + 1, options)
         end
       end
 
@@ -161,44 +178,48 @@ module Haml
       
       def dynamic_attributes
         @dynamic_attributes ||= begin
-          attributes.inject({}) do |dynamic, pair|
-            name, value = pair
-            unless value.empty?
-              full_match = nil
-              ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
-                full_match = $`.empty? && $'.empty?
-                full_match ? $1: "\#{#{$1}}"
-              end
-              unless ruby_value == value
-                dynamic[name] = full_match ? ruby_value : %("#{ruby_value}")
-              end
+          Haml::Util.map_hash(attributes) do |name, value|
+            next if value.empty?
+            full_match = nil
+            ruby_value = value.gsub(%r{<haml:loud>\s*(.+?)\s*</haml:loud>}) do
+              full_match = $`.empty? && $'.empty?
+              full_match ? $1: "\#{#{$1}}"
             end
-            dynamic
+            next if ruby_value == value
+            [name, full_match ? ruby_value : %("#{ruby_value}")]
           end
         end
       end
-      
-      def static_attribute?(name)
-        attributes[name] and !dynamic_attribute?(name)
+
+      def haml_tag_loud(text)
+        "= #{text.gsub(/\n\s*/, ' ').strip}\n"
+      end
+
+      def haml_tag_silent(text)
+        text.split("\n").map { |line| "- #{line.strip}\n" }.join
+      end
+
+      def static_attribute?(name, options)
+        attributes[name] and !dynamic_attribute?(name, options)
       end
       
-      def dynamic_attribute?(name)
-        HTML.options[:rhtml] and dynamic_attributes.key?(name)
+      def dynamic_attribute?(name, options)
+        options[:rhtml] and dynamic_attributes.key?(name)
       end
       
-      def static_id?
-        static_attribute? 'id'
+      def static_id?(options)
+        static_attribute?('id', options)
       end
       
-      def static_classname?
-        static_attribute? 'class'
+      def static_classname?(options)
+        static_attribute?('class', options)
       end
 
       # Returns a string representation of an attributes hash
       # that's prettier than that produced by Hash#inspect
-      def haml_attributes
+      def haml_attributes(options)
         attrs = attributes.map do |name, value|
-          value = dynamic_attribute?(name) ? dynamic_attributes[name] : value.inspect
+          value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
           name = name.index(/\W/) ? name.inspect : ":#{name}"
           "#{name} => #{value}"
         end
@@ -206,14 +227,6 @@ module Haml
       end
     end
 
-    def self.haml_tag_loud(text)
-      "= #{text.gsub(/\n\s*/, ' ').strip}\n"
-    end
-
-    def self.haml_tag_silent(text)
-      text.split("\n").map { |line| "- #{line.strip}\n" }.join
-    end
-
     private
 
     def match_to_html(string, regex, tag)
@@ -221,6 +234,5 @@ module Haml
         "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
       end
     end
-    # :startdoc:
   end
 end