haml_ejs 0.0.1

data/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,57 @@
+module Haml
+  module Helpers
+    @@action_view_defined = true
+
+    # 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](http://sass-lang.com)),
+      # 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
+
+      # Treats all input to \{Haml::Helpers#haml\_concat} within the block
+      # as being HTML safe for Rails' XSS protection.
+      # This is useful for wrapping blocks of code that concatenate HTML en masse.
+      #
+      # This has no effect if Rails' XSS protection isn't enabled.
+      #
+      # @yield A block in which all input to `#haml_concat` is treated as raw.
+      # @see Haml::Util#rails_xss_safe?
+      def with_raw_haml_concat
+        @_haml_concat_raw, old = true, @_haml_concat_raw
+        yield
+      ensure
+        @_haml_concat_raw = old
+      end
+    end
+
+    include ActionViewExtensions
+  end
+end

data/lib/haml/helpers/action_view_mods.rb

@@ -0,0 +1,257 @@
+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?
+          new = String.new(new) if Haml::Util.rails_xss_safe? &&
+            new.is_a?(Haml::Util.rails_safe_buffer_class)
+          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)
+            value = nil
+            buffer = capture_haml(*args) { value = yield(*args) }
+            return buffer unless buffer.empty?
+            return value if value.is_a?(String)
+          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)
+            _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
+            value = nil
+            buffer = capture_haml(*args) { value = yield(*args) }
+            str =
+              if !buffer.empty?
+                buffer
+              elsif value.is_a?(String)
+                value
+              else
+                ''
+              end
+            return ActionView::NonConcattingString.new(str) if defined?(ActionView::NonConcattingString)
+            return str
+          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
+
+        content = content_tag_without_haml(name, *args, &block)
+        content = Haml::Helpers.preserve(content) if preserve && content
+        content
+      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
+
+      def content_tag(*args)
+        html_tag = content_tag_with_haml(*args)
+        return html_tag unless respond_to?(:error_wrapping)
+        return error_wrapping(html_tag) if method(:error_wrapping).arity == 1
+        return html_tag unless object.respond_to?(:errors) && object.errors.respond_to?(:on)
+        return error_wrapping(html_tag, object.errors.on(@method_name))
+      end
+    end
+
+    if Haml::Util.ap_geq_3?
+      module FormTagHelper
+        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
+          if is_haml?
+            wrap_block = block_given? && block_is_haml?(proc)
+            if wrap_block
+              oldproc = proc
+              proc = haml_bind_proc do |*args|
+                concat "\n"
+                with_tabs(1) {oldproc.call(*args)}
+              end
+            end
+            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
+            res << "\n" if wrap_block
+            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)
+          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
+          if wrap_block
+            oldproc = proc
+            proc = proc {|*args| with_tabs(1) {oldproc.call(*args)}}
+          end
+          res = form_for_without_haml(object_name, *args, &proc)
+          res << "\n" if wrap_block
+          res
+        end
+        alias_method :form_for_without_haml, :form_for
+        alias_method :form_for, :form_for_with_haml
+      end
+
+      module CacheHelper
+        # This is a workaround for a Rails 3 bug
+        # that's present at least through beta 3.
+        # Their fragment_for assumes that the block
+        # will return its contents as a string,
+        # which is not always the case.
+        # Luckily, it only makes this assumption if caching is disabled,
+        # so we only override that case.
+        def fragment_for_with_haml(*args, &block)
+          return fragment_for_without_haml(*args, &block) if controller.perform_caching
+          capture(&block)
+        end
+        alias_method :fragment_for_without_haml, :fragment_for
+        alias_method :fragment_for, :fragment_for_with_haml
+      end
+    else
+      module FormTagHelper
+        def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
+          if is_haml?
+            wrap_block = block_given? && block_is_haml?(proc)
+            if wrap_block
+              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"
+            if block_given?
+              concat "\n"
+              return Haml::Helpers::ErrorReturn.new("form_tag")
+            end
+            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)
+          wrap_block = block_given? && is_haml? && block_is_haml?(proc)
+          if wrap_block
+            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 wrap_block
+          Haml::Helpers::ErrorReturn.new("form_for") if is_haml?
+        end
+        alias_method :form_for_without_haml, :form_for
+        alias_method :form_for, :form_for_with_haml
+      end
+    end
+  end
+end

data/lib/haml/helpers/xss_mods.rb

@@ -0,0 +1,165 @@
+module Haml
+  module Helpers
+    # This module overrides Haml helpers to work properly
+    # in the context of ActionView.
+    # Currently it's only used for modifying the helpers
+    # 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_indent
+           haml_tag escape_once].each do |name|
+          base.send(:alias_method, "#{name}_without_haml_xss", name)
+          base.send(:alias_method, name, "#{name}_with_haml_xss")
+        end
+      end
+
+      # Don't escape text that's already safe,
+      # output is always HTML safe
+      def html_escape_with_haml_xss(text)
+        str = text.to_s
+        return text if str.html_safe?
+        Haml::Util.html_safe(html_escape_without_haml_xss(str))
+      end
+
+      # Output is always HTML safe
+      def find_and_preserve_with_haml_xss(*args, &block)
+        Haml::Util.html_safe(find_and_preserve_without_haml_xss(*args, &block))
+      end
+
+      # Output is always HTML safe
+      def preserve_with_haml_xss(*args, &block)
+        Haml::Util.html_safe(preserve_without_haml_xss(*args, &block))
+      end
+
+      # Output is always HTML safe
+      def list_of_with_haml_xss(*args, &block)
+        Haml::Util.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)
+        Haml::Util.html_safe(
+          surround_without_haml_xss(
+            haml_xss_html_escape(front),
+            haml_xss_html_escape(back),
+            &block))
+      end
+
+      # Input is escaped, output is always HTML safe
+      def precede_with_haml_xss(str, &block)
+        Haml::Util.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)
+        Haml::Util.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)
+        Haml::Util.html_safe(capture_haml_without_haml_xss(*args, &block))
+      end
+
+      # Input is escaped
+      def haml_concat_with_haml_xss(text = "")
+        haml_concat_without_haml_xss(@_haml_concat_raw ? text : haml_xss_html_escape(text))
+      end
+
+      # Output is always HTML safe
+      def haml_indent_with_haml_xss
+        Haml::Util.html_safe(haml_indent_without_haml_xss)
+      end
+
+      # Input is escaped, haml_concat'ed output is always HTML safe
+      def haml_tag_with_haml_xss(name, *rest, &block)
+        name = haml_xss_html_escape(name.to_s)
+        rest.unshift(haml_xss_html_escape(rest.shift.to_s)) unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
+        with_raw_haml_concat {haml_tag_without_haml_xss(name, *rest, &block)}
+      end
+
+      # Output is always HTML safe
+      def escape_once_with_haml_xss(*args)
+        Haml::Util.html_safe(escape_once_without_haml_xss(*args))
+      end
+
+      private
+
+      # 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 Haml::Util.rails_xss_safe? && haml_buffer.options[:escape_html]
+        html_escape(text)
+      end
+    end
+
+    class ErrorReturn
+      # Any attempt to treat ErrorReturn as a string should cause it to blow up.
+      alias_method :html_safe, :to_s
+      alias_method :html_safe?, :to_s
+      alias_method :html_safe!, :to_s
+    end
+  end
+end
+
+module ActionView
+  module Helpers
+    module CaptureHelper
+      def with_output_buffer_with_haml_xss(*args, &block)
+        res = with_output_buffer_without_haml_xss(*args, &block)
+        case res
+        when Array; res.map {|s| Haml::Util.html_safe(s)}
+        when String; Haml::Util.html_safe(res)
+        else; res
+        end
+      end
+      alias_method :with_output_buffer_without_haml_xss, :with_output_buffer
+      alias_method :with_output_buffer, :with_output_buffer_with_haml_xss
+    end
+
+    module FormTagHelper
+      def form_tag_with_haml_xss(*args, &block)
+        res = form_tag_without_haml_xss(*args, &block)
+        res = Haml::Util.html_safe(res) unless block_given?
+        res
+      end
+      alias_method :form_tag_without_haml_xss, :form_tag
+      alias_method :form_tag, :form_tag_with_haml_xss
+    end
+
+    module FormHelper
+      def form_for_with_haml_xss(*args, &block)
+        res = form_for_without_haml_xss(*args, &block)
+        return Haml::Util.html_safe(res) if res.is_a?(String)
+        return res
+      end
+      alias_method :form_for_without_haml_xss, :form_for
+      alias_method :form_for, :form_for_with_haml_xss
+    end
+
+    module TextHelper
+      def concat_with_haml_xss(string)
+        if is_haml?
+          haml_buffer.buffer.concat(haml_xss_html_escape(string))
+        else
+          concat_without_haml_xss(string)
+        end
+      end
+      alias_method :concat_without_haml_xss, :concat
+      alias_method :concat, :concat_with_haml_xss
+
+      # safe_concat was introduced in Rails 3.0
+      if Haml::Util.has?(:instance_method, self, :safe_concat)
+        def safe_concat_with_haml_xss(string)
+          if is_haml?
+            haml_buffer.buffer.concat(string)
+          else
+            safe_concat_without_haml_xss(string)
+          end
+        end
+        alias_method :safe_concat_without_haml_xss, :safe_concat
+        alias_method :safe_concat, :safe_concat_with_haml_xss
+      end
+    end
+  end
+end