simple-templater 0.0.1.4 → 0.0.1.5

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

@@ -1,341 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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