wireframe-haml 2.1.0

data/lib/haml/filters.rb

@@ -0,0 +1,276 @@
+module Haml
+  # The module containing the default filters,
+  # as well as the base module,
+  # Haml::Filters::Base.
+  module Filters
+    # Returns a hash of defined filters.
+    def self.defined
+      @defined ||= {}
+    end
+
+    # The base module for Haml filters.
+    # User-defined filters should be modules including this module.
+    #
+    # A user-defined filter should override either Base#render or Base #compile.
+    # Base#render is the most common.
+    # It takes a string, the filter source,
+    # and returns another string,
+    # the result of the filter.
+    # For example:
+    #
+    #   module Haml::Filters::Sass
+    #     include Haml::Filters::Base
+    #
+    #     def render(text)
+    #       ::Sass::Engine.new(text).render
+    #     end
+    #   end
+    #
+    # For details on overriding #compile, see its documentation.
+    #
+    module Base
+      def self.included(base) # :nodoc:
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
+        base.instance_variable_set "@lazy_requires", nil
+      end
+
+      # Takes a string, the source text that should be passed to the filter,
+      # and returns the string resulting from running the filter on <tt>text</tt>.
+      #
+      # This should be overridden in most individual filter modules
+      # to render text with the given filter.
+      # If compile is overridden, however, render doesn't need to be.
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
+      end
+
+      # Same as render, but takes the Haml options hash as well.
+      # It's only safe to rely on options made available in Haml::Engine#options_for_buffer.
+      def render_with_options(text, options)
+        render(text)
+      end
+
+      def internal_compile(*args) # :nodoc:
+        resolve_lazy_requires
+        compile(*args)
+      end
+
+      # compile should be overridden when a filter needs to have access
+      # to the Haml evaluation context.
+      # Rather than applying a filter to a string at compile-time,
+      # compile uses the Haml::Precompiler instance to compile the string to Ruby code
+      # that will be executed in the context of the active Haml template.
+      #
+      # Warning: the Haml::Precompiler interface is neither well-documented
+      # nor guaranteed to be stable.
+      # If you want to make use of it,
+      # you'll probably need to look at the source code
+      # and should test your filter when upgrading to new Haml versions.
+      def compile(precompiler, text)
+        resolve_lazy_requires
+        filter = self
+        precompiler.instance_eval do
+          if contains_interpolation?(text)
+            return if options[:suppress_eval]
+
+            push_script <<RUBY
+find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
+RUBY
+            return
+          end
+
+          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, precompiler.options), precompiler.options[:preserve])
+
+          if !options[:ugly]
+            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
+          else
+            push_text(rendered.rstrip)
+          end
+        end
+      end
+
+      # This becomes a class method of modules that include Base.
+      # It allows the module to specify one or more Ruby files
+      # that Haml should try to require when compiling the filter.
+      #
+      # The first file specified is tried first,
+      # then the second, etc.
+      # If none are found, the compilation throws an exception.
+      #
+      # For example:
+      #
+      #   module Haml::Filters::Markdown
+      #     lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+      #
+      #     ...
+      #   end
+      #
+      def lazy_require(*reqs)
+        @lazy_requires = reqs
+      end
+
+      private
+
+      def resolve_lazy_requires
+        return unless @lazy_requires
+
+        @lazy_requires[0...-1].each do |req|
+          begin
+            @required = req
+            require @required
+            return
+          rescue LoadError; end # RCov doesn't see this, but it is run
+        end
+
+        begin
+          @required = @lazy_requires[-1]
+          require @required
+        rescue LoadError => e
+          classname = self.name.match(/\w+$/)[0]
+
+          if @lazy_requires.size == 1
+            raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
+          else
+            raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
+          end
+        end
+      end
+    end
+  end
+end
+
+# :stopdoc:
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+module Haml
+  module Filters
+    module Plain
+      include Base
+
+      def render(text); text; end
+    end
+
+    module Javascript
+      include Base
+
+      def render_with_options(text, options)
+        <<END
+<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>
+  //<![CDATA[
+    #{text.rstrip.gsub("\n", "\n    ")}
+  //]]>
+</script>
+END
+      end
+    end
+
+    module Cdata
+      include Base
+
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    module Escaped
+      include Base
+
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
+    module Ruby
+      include Base
+      lazy_require 'stringio'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        precompiler.instance_eval do
+          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
+            _haml_old_stdout = $stdout
+            $stdout = StringIO.new(_hamlout.buffer, 'a')
+          FIRST
+            _haml_old_stdout, $stdout = $stdout, _haml_old_stdout
+            _haml_old_stdout.close
+          LAST
+        end
+      end
+    end
+
+    module Preserve
+      include Base
+
+      def render(text)
+        Haml::Helpers.preserve text
+      end
+    end
+
+    module Sass
+      include Base
+      lazy_require 'sass/plugin'
+
+      def render(text)
+        ::Sass::Engine.new(text, ::Sass::Plugin.engine_options).render
+      end
+    end
+
+    module ERB
+      include Base
+      lazy_require 'erb'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        src = ::ERB.new(text).src.sub(/^#coding:.*?\n/, '').
+          sub(/^_erbout = '';/, "").gsub("\n", ';')
+        precompiler.send(:push_silent, src)
+      end
+    end
+
+    module Textile
+      include Base
+      lazy_require 'redcloth'
+
+      def render(text)
+        ::RedCloth.new(text).to_html(:textile)
+      end
+    end
+    RedCloth = Textile
+    Filters.defined['redcloth'] = RedCloth
+
+    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
+    module Markdown
+      include Base
+      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+
+      def render(text)
+        engine = case @required
+                 when 'rdiscount'
+                   ::RDiscount
+                 when 'peg_markdown'
+                   ::PEGMarkdown
+                 when 'maruku'
+                   ::Maruku
+                 when 'bluecloth'
+                   ::BlueCloth
+                 end
+        engine.new(text).to_html
+      end
+    end
+
+    module Maruku
+      include Base
+      lazy_require 'maruku'
+
+      def render(text)
+        ::Maruku.new(text).to_html
+      end
+    end
+  end
+end
+
+# :startdoc:

data/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,45 @@
+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:
+      end
+    end
+  end
+end

data/lib/haml/helpers/action_view_mods.rb

@@ -0,0 +1,181 @@
+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)
+      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
+
+    # 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
+          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
+
+        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
+                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
+      # :startdoc:
+    end
+  end
+end
+