simple-templater 0.0.1.3 → 0.0.1.4

data/gems/gems/haml-2.2.16/lib/haml/filters.rb

@@ -0,0 +1,341 @@
+module Haml
+  # The module containing the default Haml filters,
+  # as well as the base module, {Haml::Filters::Base}.
+  #
+  # @see Haml::Filters::Base
+  module Filters
+    # @return [{String => Haml::Filters::Base}] a hash of filter names to classes
+    def self.defined
+      @defined ||= {}
+    end
+
+    # The base module for Haml filters.
+    # User-defined filters should be modules including this module.
+    # The name of the filter is taken by downcasing the module name.
+    # For instance, if the module is named `FooBar`, the filter will be `:foobar`.
+    #
+    # A user-defined filter should override either \{#render} or {\#compile}.
+    # \{#render} is the most common.
+    # It takes a string, the filter source,
+    # and returns another string, the result of the filter.
+    # For example, the following will define a filter named `:sass`:
+    #
+    #     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.
+    #
+    # Note that filters overriding \{#render} automatically support `#{}`
+    # for interpolating Ruby code.
+    # Those overriding \{#compile} will need to add such support manually
+    # if it's desired.
+    module Base
+      # This method is automatically called when {Base} is included in a module.
+      # It automatically defines a filter
+      # with the downcased name of that module.
+      # For example, if the module is named `FooBar`, the filter will be `:foobar`.
+      #
+      # @param base [Module, Class] The module that this is included in
+      def self.included(base)
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
+      end
+
+      # Takes the source text that should be passed to the filter
+      # and returns the result of running the filter on that string.
+      #
+      # 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.
+      #
+      # @param text [String] The source text for the filter to process
+      # @return [String] The filtered result
+      # @raise [Haml::Error] if it's not overridden
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
+      end
+
+      # Same as \{#render}, but takes a {Haml::Engine} options hash as well.
+      # It's only safe to rely on options made available in {Haml::Engine#options\_for\_buffer}.
+      #
+      # @see #render
+      # @param text [String] The source text for the filter to process
+      # @return [String] The filtered result
+      # @raise [Haml::Error] if it or \{#render} isn't overridden
+      def render_with_options(text, options)
+        render(text)
+      end
+
+      # Same as \{#compile}, but requires the necessary files first.
+      # *This is used by {Haml::Engine} and is not intended to be overridden or used elsewhere.*
+      #
+      # @see #compile
+      def internal_compile(*args)
+        resolve_lazy_requires
+        compile(*args)
+      end
+
+      # This 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.
+      #
+      # @param precompiler [Haml::Precompiler] The precompiler instance
+      # @param text [String] The text of the filter
+      # @raise [Haml::Error] if none of \{#compile}, \{#render}, and \{#render_with_options} are overridden
+      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, :escape_html => false
+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
+      #
+      # @param reqs [Array<String>] The requires to run
+      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
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+module Haml
+  module Filters
+    # Does not parse the filtered text.
+    # This is useful for large blocks of text without HTML tags,
+    # when you don't want lines starting with `.` or `-`
+    # to be parsed.
+    module Plain
+      include Base
+
+      # @see Base#render
+      def render(text); text; end
+    end
+
+    # Surrounds the filtered text with `<script>` and CDATA tags.
+    # Useful for including inline Javascript.
+    module Javascript
+      include Base
+
+      # @see Base#render_with_options
+      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
+
+    # Surrounds the filtered text with CDATA tags.
+    module Cdata
+      include Base
+
+      # @see Base#render
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    # Works the same as {Plain}, but HTML-escapes the text
+    # before placing it in the document.
+    module Escaped
+      include Base
+
+      # @see Base#render
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
+    # Parses the filtered text with the normal Ruby interpreter.
+    # All output sent to `$stdout`, such as with `puts`,
+    # is output into the Haml document.
+    # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
+    # The Ruby code is evaluated in the same context as the Haml template.
+    module Ruby
+      include Base
+      lazy_require 'stringio'
+
+      # @see Base#compile
+      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
+
+    # Inserts the filtered text into the template with whitespace preserved.
+    # `preserve`d blocks of text aren't indented,
+    # and newlines are replaced with the HTML escape code for newlines,
+    # to preserve nice-looking output.
+    #
+    # @see Haml::Helpers#preserve
+    module Preserve
+      include Base
+
+      # @see Base#render
+      def render(text)
+        Haml::Helpers.preserve text
+      end
+    end
+
+    # Parses the filtered text with {Sass} to produce CSS output.
+    module Sass
+      include Base
+      lazy_require 'sass/plugin'
+
+      # @see Base#render
+      def render(text)
+        ::Sass::Engine.new(text, ::Sass::Plugin.engine_options).render
+      end
+    end
+
+    # Parses the filtered text with ERB, like an RHTML template.
+    # Not available if the {file:HAML_REFERENCE.md#suppress_eval-option `:suppress_eval`} option is set to true.
+    # Embedded Ruby code is evaluated in the same context as the Haml template.
+    module ERB
+      include Base
+      lazy_require 'erb'
+
+      # @see Base#compile
+      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
+
+    # Parses the filtered text with [Textile](http://www.textism.com/tools/textile).
+    # Only works if [RedCloth](http://redcloth.org) is installed.
+    module Textile
+      include Base
+      lazy_require 'redcloth'
+
+      # @see Base#render
+      def render(text)
+        ::RedCloth.new(text).to_html(:textile)
+      end
+    end
+    RedCloth = Textile
+    Filters.defined['redcloth'] = RedCloth
+
+    # Parses the filtered text with [Markdown](http://daringfireball.net/projects/markdown).
+    # Only works if [RDiscount](http://github.com/rtomayko/rdiscount),
+    # [RPeg-Markdown](http://github.com/rtomayko/rpeg-markdown),
+    # [Maruku](http://maruku.rubyforge.org),
+    # or [BlueCloth](www.deveiate.org/projects/BlueCloth) are installed.
+    module Markdown
+      include Base
+      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+
+      # @see Base#render
+      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
+
+    # Parses the filtered text with [Maruku](http://maruku.rubyforge.org),
+    # which has some non-standard extensions to Markdown.
+    module Maruku
+      include Base
+      lazy_require 'maruku'
+
+      # @see Base#render
+      def render(text)
+        ::Maruku.new(text).to_html
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,55 @@
+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
+
+      # 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 = true
+        yield
+      ensure
+        @_haml_concat_raw = false
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/haml/helpers/action_view_mods.rb

@@ -0,0 +1,177 @@
+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?(ActionView::SafeBuffer)
+          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/gems/gems/haml-2.2.16/lib/haml/helpers/xss_mods.rb

@@ -0,0 +1,95 @@
+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?
+        html_escape_without_haml_xss(str).html_safe!
+      end
+
+      # Output is always HTML safe
+      def find_and_preserve_with_haml_xss(*args, &block)
+        find_and_preserve_without_haml_xss(*args, &block).html_safe!
+      end
+
+      # Output is always HTML safe
+      def preserve_with_haml_xss(*args, &block)
+        preserve_without_haml_xss(*args, &block).html_safe!
+      end
+
+      # Output is always HTML safe
+      def list_of_with_haml_xss(*args, &block)
+        list_of_without_haml_xss(*args, &block).html_safe!
+      end
+
+      # Input is escaped, output is always HTML safe
+      def surround_with_haml_xss(front, back = front, &block)
+        surround_without_haml_xss(
+          haml_xss_html_escape(front),
+          haml_xss_html_escape(back),
+          &block).html_safe!
+      end
+
+      # Input is escaped, output is always HTML safe
+      def precede_with_haml_xss(str, &block)
+        precede_without_haml_xss(haml_xss_html_escape(str), &block).html_safe!
+      end
+
+      # Input is escaped, output is always HTML safe
+      def succeed_with_haml_xss(str, &block)
+        succeed_without_haml_xss(haml_xss_html_escape(str), &block).html_safe!
+      end
+
+      # Output is always HTML safe
+      def capture_haml_with_haml_xss(*args, &block)
+        capture_haml_without_haml_xss(*args, &block).html_safe!
+      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_indent_without_haml_xss.html_safe!
+      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)
+        escape_once_without_haml_xss(*args).html_safe!
+      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
+  end
+end