drnic-haml 2.3.0

data/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,40 @@
+require 'haml/helpers/action_view_mods'
+
+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

@@ -0,0 +1,176 @@
+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 :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
+      end
+      alias_method :set_output_buffer_without_haml, :output_buffer=
+      alias_method :output_buffer=, :set_output_buffer_with_haml
+    end
+  end
+
+  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
+            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
+        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
+        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
+        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?
+
+        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
+      end
+
+      alias_method :content_tag_without_haml, :content_tag
+      alias_method :content_tag, :content_tag_with_haml
+    end
+
+    class InstanceTag
+      # Includes TagHelper
+
+      def haml_buffer
+        @template_object.send :haml_buffer
+      end
+
+      def is_haml?
+        @template_object.send :is_haml?
+      end
+
+      unless defined?(ActionView::Helpers::ActiveRecordInstanceTag)
+        alias_method :content_tag_without_haml, :content_tag
+        alias_method :content_tag, :content_tag_with_haml
+      end
+    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
+    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/herb.rb

@@ -0,0 +1,96 @@
+# Modified version of ERB specifically used to help convert ERB templates to Haml
+class ERB
+  class HamlCompiler < Compiler # :nodoc:
+    class Buffer # :nodoc:
+      def initialize(compiler, delimiter)
+        @compiler = compiler
+        @line = []
+        @script = ""
+        @delimiter = delimiter
+        @compiler.pre_cmd.each do |x|
+          push(x)
+        end
+      end
+      attr_reader :script
+
+      def push(cmd)
+        @line << cmd
+      end
+      
+      def cr
+        @script << (@line.join(@delimiter))
+        @line = []
+        @script << @delimiter
+      end
+      
+      def close
+        return unless @line
+        @compiler.post_cmd.each do |x|
+          push(x)
+        end
+        @script << (@line.join(@delimiter))
+        @line = nil
+      end
+    end
+
+    def compile(s, delimiter = '; ')
+      out = Buffer.new(self, delimiter)
+
+      content = ''
+      scanner = make_scanner(s)
+      scanner.scan do |token|
+        if scanner.stag.nil?
+          case token
+          when PercentLine
+            out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+            content = ''
+            out.push(token.to_s)
+            out.cr
+          when :cr
+            out.cr
+          when '<%', '<%=', '<%#'
+            scanner.stag = token
+            out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+            content = ''
+          when "\n"
+            content << "\n"
+            out.push("#{@put_cmd} #{content.dump}")
+            out.cr
+            content = ''
+          when '<%%'
+            content << '<%'
+          else
+            content << token
+          end
+        else
+          case token
+          when '%>'
+            case scanner.stag
+            when '<%'
+              if content[-1] == ?\n
+                content.chop!
+                out.push(content)
+                out.cr
+              else
+                out.push(content)
+              end
+            when '<%='
+              out.push("#{@insert_cmd}((#{content}).to_s)")
+            when '<%#'
+              # out.push("# #{content.dump}")
+            end
+            scanner.stag = nil
+            content = ''
+          when '%%>'
+            content << '%>'
+          else
+            content << token
+          end
+        end
+      end
+      out.push("#{@put_cmd} #{content.dump}") if content.size > 0
+      out.close
+      out.script
+    end
+  end
+end

data/lib/haml/html.rb

@@ -0,0 +1,308 @@
+require File.dirname(__FILE__) + '/../haml'
+
+require 'haml/engine'
+require 'rubygems'
+require 'cgi'
+require 'haml/herb'
+require 'parse_tree'
+
+module Haml
+  class HTML
+    # A module containing utility methods that every Hpricot node
+    # should have.
+    module Node
+      # 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
+
+      private
+
+      def tabulate(tabs)
+        '  ' * tabs
+      end
+
+      def parse_text(text, tabs)
+        text.strip!
+        if text.empty?
+          String.new
+        else
+          lines = text.split("\n")
+
+          lines.map do |line|
+            line.strip!
+            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+          end.join
+        end
+      end
+    end
+  end
+end
+
+# Haml monkeypatches various Hpricot classes
+# to add methods for conversion to Haml.
+module Hpricot
+  # @see Hpricot
+  module Node
+    include Haml::HTML::Node
+  end
+
+  # @see Hpricot
+  class BaseEle
+    include Haml::HTML::Node
+  end
+end
+
+require 'hpricot'
+
+module Haml
+  # 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
+    # @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
+
+      if template.is_a? Hpricot::Node
+        @template = template
+      else
+        if template.is_a? IO
+          template = template.read
+        end
+
+        Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+
+        if @options[:rhtml]
+          template = convert_to_hamlified_markup(template)
+        end
+
+        method = @options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
+        @template = method.call(template.gsub('&', '&amp;'))
+      end
+    end
+
+    # Processes the document and returns the result as a string
+    # containing the Haml template.
+    def render
+      @template.to_haml(0, @options)
+    end
+    alias_method :to_haml, :render
+
+    TEXT_REGEXP = /^(\s*).*$/
+
+    # @see Hpricot
+    class ::Hpricot::Doc
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        (children || []).inject('') {|s, c| s << c.to_haml(0, options)}
+      end
+    end
+
+    # @see Hpricot
+    class ::Hpricot::XMLDecl
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        "#{tabulate(tabs)}!!! XML\n"
+      end
+    end
+
+    # @see Hpricot
+    class ::Hpricot::CData
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
+      end
+    end
+
+    # @see Hpricot
+    class ::Hpricot::DocType
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
+        raise Haml::SyntaxError.new("Invalid doctype") if attrs == nil
+
+        type, version, strictness = attrs.map { |a| a.downcase }
+        if type == "html"
+          version = "1.0"
+          strictness = "transitional"
+        end
+
+        if version == "1.0" || version.empty?
+          version = nil
+        end
+
+        if strictness == 'transitional' || strictness.empty?
+          strictness = nil
+        end
+
+        version = " #{version}" if version
+        if strictness
+          strictness[0] = strictness[0] - 32
+          strictness = " #{strictness}"
+        end
+
+        "#{tabulate(tabs)}!!!#{version}#{strictness}\n"
+      end
+    end
+
+    # @see Hpricot
+    class ::Hpricot::Comment
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
+      end
+    end
+
+    # @see Hpricot
+    class ::Hpricot::Elem
+      # @see Haml::HTML::Node#to_haml
+      def to_haml(tabs, options)
+        output = tab_prefix = "#{tabulate(tabs)}"
+        if options[:rhtml] && name[0...5] == 'haml:'
+          output = (self.children || []).inject("") do |out, child|
+            if child.text?
+              text = CGI.unescapeHTML(child.inner_text).strip
+              text.gsub!(/(^[- ]+)|([- ]+$)/, '')
+              next out if text.empty?
+              out + tab_prefix + send("haml_tag_#{name[5..-1]}", text, tab_prefix)
+            elsif child.name[0...10] == 'haml:block'
+              out + child.to_haml(tabs + 1, options)
+            elsif child.name[0...5] == 'haml:'
+              out + child.to_haml(tabs, options)
+            else
+              out + child.to_haml(tabs, options)
+            end
+          end
+          return output
+        end
+
+        output += "%#{name}" unless name == 'div' &&
+          (static_id?(options) || static_classname?(options))
+
+        if attributes
+          if static_id?(options)
+            output += "##{attributes['id']}"
+            remove_attribute('id')
+          end
+          if static_classname?(options)
+            attributes['class'].split(' ').each { |c| output += ".#{c}" }
+            remove_attribute('class')
+          end
+          output += haml_attributes(options) if attributes.length > 0
+        end
+
+        (self.children || []).inject(output + "\n") do |output, child|
+          output + child.to_haml(tabs + 1, options)
+        end
+      end
+
+      private
+      
+      def dynamic_attributes
+        @dynamic_attributes ||= begin
+          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
+            next if ruby_value == value
+            [name, full_match ? ruby_value : %("#{ruby_value}")]
+          end
+        end
+      end
+
+      def haml_tag_loud(text, tab_prefix = '')
+        if text =~ /\n/
+          lines = text.strip.split(/\n+/)
+          pad_size = lines.map { |line| line.length }.max + 1
+          out = lines.map { |line| tab_prefix + "  " + line.ljust(pad_size) + '|' }.join("\n")
+          out[0...4] = "= "
+          out + "\n"
+        else
+          "= #{text.gsub(/\n\s*/, ' ').strip}\n"
+        end
+      end
+
+      def haml_tag_silent(text, tab_prefix = '')
+        text.strip.split("\n").map { |line| "- #{line.strip}" }.join("\n#{tab_prefix}") + "\n"
+      end
+      
+      def haml_tag_block(text, tab_prefix = '')
+        "#{text.strip}\n"
+      end
+
+      def static_attribute?(name, options)
+        attributes[name] and !dynamic_attribute?(name, options)
+      end
+      
+      def dynamic_attribute?(name, options)
+        options[:rhtml] and dynamic_attributes.key?(name)
+      end
+      
+      def static_id?(options)
+        static_attribute?('id', options)
+      end
+      
+      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(options)
+        attrs = attributes.map do |name, value|
+          value = dynamic_attribute?(name, options) ? dynamic_attributes[name] : value.inspect
+          name = name.index(/\W/) ? name.inspect : ":#{name}"
+          "#{name} => #{value}"
+        end
+        "{ #{attrs.join(', ')} }"
+      end
+    end
+
+    private
+    
+    TOKEN_DELIMITER = '__oHg5SJYRHA0__'
+    
+    def convert_to_hamlified_markup(string)      
+      output = ''
+      compiler = ERB::HamlCompiler.new(nil)
+      compiler.insert_cmd = compiler.put_cmd = '_erbout.concat'
+
+      lines = compiler.compile(string, TOKEN_DELIMITER).split(TOKEN_DELIMITER)
+      lines.each do |code|
+        code.gsub!(/(^[- ]+)|([- ]+$)/, '')
+        output << if code[0...15] == '_erbout.concat '
+          code[0...15] = ''
+          eval(code)
+        elsif code =~ /^_erbout\.concat\(\((.*)\)\.to_s\)$/m
+          "<haml:loud>#{$1}</haml:loud>"
+        elsif code == 'end'
+          "</haml:block></haml:silent>"
+        else
+          begin
+            ParseTree.translate(code)
+            "<haml:silent>#{code}</haml:silent>"
+          rescue Exception
+            "<haml:silent>#{code}<haml:block>"
+          end
+        end
+      end
+      output
+    end
+
+  end
+end