brakeman 4.3.1 → 5.0.0

data/bundle/ruby/2.5.0/gems/haml-4.0.7/lib/haml/filters.rb

@@ -1,404 +0,0 @@
-require "tilt"
-
-module Haml
-  # The module containing the default Haml filters,
-  # as well as the base module, {Haml::Filters::Base}.
-  #
-  # @see Haml::Filters::Base
-  module Filters
-
-    extend self
-
-    # @return [{String => Haml::Filters::Base}] a hash mapping filter names to
-    #   classes.
-    attr_reader :defined
-    @defined = {}
-
-    # Loads an external template engine from
-    # [Tilt](https://github.com/rtomayko/tilt) as a filter. This method is used
-    # internally by Haml to set up filters for Sass, SCSS, Less, Coffeescript,
-    # and others. It's left public to make it easy for developers to add their
-    # own Tilt-based filters if they choose.
-    #
-    # @return [Module] The generated filter.
-    # @param [Hash] options Options for generating the filter module.
-    # @option options [Boolean] :precompiled Whether the filter should be
-    #   precompiled. Erb, Nokogiri and Builder use this, for example.
-    # @option options [Class] :template_class The Tilt template class to use,
-    #   in the event it can't be inferred from an extension.
-    # @option options [String] :extension The extension associated with the
-    #   content, for example "markdown". This lets Tilt choose the preferred
-    #   engine when there are more than one.
-    # @option options [String,Array<String>] :alias Any aliases for the filter.
-    #   For example, :coffee is also available as :coffeescript.
-    # @option options [String] :extend The name of a module to extend when
-    #   defining the filter. Defaults to "Plain". This allows filters such as
-    #   Coffee to "inherit" from Javascript, wrapping its output in script tags.
-    # @since 4.0
-    def register_tilt_filter(name, options = {})
-      if constants.map(&:to_s).include?(name.to_s)
-        raise "#{name} filter already defined"
-      end
-
-      filter = const_set(name, Module.new)
-      filter.extend const_get(options[:extend] || "Plain")
-      filter.extend TiltFilter
-      filter.extend PrecompiledTiltFilter if options.has_key? :precompiled
-
-      if options.has_key? :template_class
-        filter.template_class = options[:template_class]
-      else
-        filter.tilt_extension = options.fetch(:extension) { name.downcase }
-      end
-
-      # All ":coffeescript" as alias for ":coffee", etc.
-      if options.has_key?(:alias)
-        [options[:alias]].flatten.each {|x| Filters.defined[x.to_s] = filter}
-      end
-      filter
-    end
-
-    # Removes a filter from Haml. If the filter was removed, it returns
-    # the that was remove Module upon success, or nil on failure. If you try
-    # to redefine a filter, Haml will raise an error. Use this method first to
-    # explicitly remove the filter before redefining it.
-    # @return Module The filter module that has been removed
-    # @since 4.0
-    def remove_filter(name)
-      defined.delete name.to_s.downcase
-      if constants.map(&:to_s).include?(name.to_s)
-        remove_const name.to_sym
-      end
-    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)
-        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::Compiler} instance to compile
-      # the string to Ruby code that will be executed in the context of the
-      # active Haml template.
-      #
-      # Warning: the {Haml::Compiler} 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 compiler [Haml::Compiler] The compiler 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(compiler, text)
-        filter = self
-        compiler.instance_eval do
-          if contains_interpolation?(text)
-            return if options[:suppress_eval]
-
-            text = unescape_interpolation(text).gsub(/(\\+)n/) do |s|
-              escapes = $1.size
-              next s if escapes % 2 == 0
-              ("\\" * (escapes - 1)) + "\n"
-            end
-            # We need to add a newline at the beginning to get the
-            # filter lines to line up (since the Haml filter contains
-            # a line that doesn't show up in the source, namely the
-            # filter name). Then we need to escape the trailing
-            # newline so that the whole filter block doesn't take up
-            # too many.
-            text = "\n" + text.sub(/\n"\Z/, "\\n\"")
-            push_script <<RUBY.rstrip, :escape_html => false
-find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _hamlout.options))
-RUBY
-            return
-          end
-
-          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, compiler.options), compiler.options[:preserve])
-
-          if options[:ugly]
-            push_text(rendered.rstrip)
-          else
-            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
-          end
-        end
-      end
-    end
-
-    # 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)
-        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
-        if options[:format] == :html5
-          type = ''
-        else
-          type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
-        end
-
-        str = "<script#{type}>\n"
-        str << "  //<![CDATA[\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  //]]>\n" if options[:cdata]
-        str << "</script>"
-
-        str
-      end
-    end
-
-    # Surrounds the filtered text with `<style>` and CDATA tags. Useful for
-    # including inline CSS.
-    module Css
-      include Base
-
-      # @see Base#render_with_options
-      def render_with_options(text, options)
-        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
-        if options[:format] == :html5
-          type = ''
-        else
-          type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
-        end
-
-        str = "<style#{type}>\n"
-        str << "  /*<![CDATA[*/\n" if options[:cdata]
-        str << "#{indent}#{text.rstrip.gsub("\n", "\n#{indent}")}\n"
-        str << "  /*]]>*/\n" if options[:cdata]
-        str << "</style>"
-
-        str
-      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. Creates an IO
-    # object named `haml_io`, anything written to it is output into the Haml
-    # document. In previous version this filter redirected any output to `$stdout`
-    # to the Haml document, this was not threadsafe and has been removed, you
-    # should use `haml_io` instead.
-    #
-    # Not available if the {file: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
-      require 'stringio'
-
-      # @see Base#compile
-      def compile(compiler, text)
-        return if compiler.options[:suppress_eval]
-        compiler.instance_eval do
-          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
-            begin
-              haml_io = StringIO.new(_hamlout.buffer, 'a')
-          FIRST
-            ensure
-              haml_io.close
-              haml_io = nil
-            end
-          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
-
-    # @private
-    module TiltFilter
-      extend self
-      attr_accessor :tilt_extension, :options
-      attr_writer :template_class
-
-      def template_class
-        (@template_class if defined? @template_class) or begin
-          @template_class = Tilt["t.#{tilt_extension}"] or
-            raise Error.new(Error.message(:cant_run_filter, tilt_extension))
-        rescue LoadError => e
-          dep = e.message.split('--').last.strip
-          raise Error.new(Error.message(:gem_install_filter_deps, tilt_extension, dep))
-        end
-      end
-
-      def self.extended(base)
-        base.options = {}
-        # There's a bug in 1.9.2 where the same parse tree cannot be shared
-        # across several singleton classes -- this bug is fixed in 1.9.3.
-        # We work around this by using a string eval instead of a block eval
-        # so that a new parse tree is created for each singleton class.
-        base.instance_eval %Q{
-          include Base
-
-          def render_with_options(text, compiler_options)
-            text = template_class.new(nil, 1, options) {text}.render
-            super(text, compiler_options)
-          end
-        }
-      end
-    end
-
-    # @private
-    module PrecompiledTiltFilter
-      def precompiled(text)
-        template_class.new(nil, 1, options) { text }.send(:precompiled, {}).first
-      end
-
-      def compile(compiler, text)
-        return if compiler.options[:suppress_eval]
-        compiler.send(:push_script, precompiled(text))
-      end
-    end
-
-    # @!parse module Sass; end
-    register_tilt_filter "Sass", :extend => "Css"
-
-    # @!parse module Scss; end
-    register_tilt_filter "Scss", :extend => "Css"
-
-    # @!parse module Less; end
-    register_tilt_filter "Less", :extend => "Css"
-
-    # @!parse module Markdown; end
-    register_tilt_filter "Markdown"
-
-    # @!parse module Erb; end
-    register_tilt_filter "Erb", :precompiled => true
-
-    # @!parse module Coffee; end
-    register_tilt_filter "Coffee", :alias => "coffeescript", :extend => "Javascript"
-
-    # Parses the filtered text with ERB.
-    # Not available if the {file: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
-      class << self
-        def precompiled(text)
-          #workaround for https://github.com/rtomayko/tilt/pull/183
-          require 'erubis' if (defined?(::Erubis) && !defined?(::Erubis::Eruby))
-          super.sub(/^#coding:.*?\n/, '')
-        end
-      end
-    end
-  end
-end
-
-# These filters have been demoted to Haml Contrib but are still included by
-# default in Haml 4.0. Still, we rescue from load error if for some reason
-# haml-contrib is not installed.
-begin
-  require "haml/filters/maruku"
-  require "haml/filters/textile"
-rescue LoadError
-end

data/bundle/ruby/2.5.0/gems/haml-4.0.7/lib/haml/helpers.rb

@@ -1,664 +0,0 @@
-module Haml
-  # This module contains various helpful methods to make it easier to do various tasks.
-  # {Haml::Helpers} is automatically included in the context
-  # that a Haml template is parsed in, so all these methods are at your
-  # disposal from within the template.
-  module Helpers
-    # An object that raises an error when \{#to\_s} is called.
-    # It's used to raise an error when the return value of a helper is used
-    # when it shouldn't be.
-    class ErrorReturn
-      def initialize(method)
-        @message = <<MESSAGE
-#{method} outputs directly to the Haml template.
-Disregard its return value and use the - operator,
-or use capture_haml to get the value as a String.
-MESSAGE
-      end
-
-      # Raises an error.
-      #
-      # @raise [Haml::Error] The error
-      def to_s
-        raise Haml::Error.new(@message)
-      rescue Haml::Error => e
-        e.backtrace.shift
-
-        # If the ErrorReturn is used directly in the template,
-        # we don't want Haml's stuff to get into the backtrace,
-        # so we get rid of the format_script line.
-        #
-        # We also have to subtract one from the Haml line number
-        # since the value is passed to format_script the line after
-        # it's actually used.
-        if e.backtrace.first =~ /^\(eval\):\d+:in `format_script/
-          e.backtrace.shift
-          e.backtrace.first.gsub!(/^\(haml\):(\d+)/) {|s| "(haml):#{$1.to_i - 1}"}
-        end
-        raise e
-      end
-
-      # @return [String] A human-readable string representation
-      def inspect
-        "Haml::Helpers::ErrorReturn(#{@message.inspect})"
-      end
-    end
-
-    self.extend self
-
-    @@action_view_defined = false
-
-    # @return [Boolean] Whether or not ActionView is loaded
-    def self.action_view?
-      @@action_view_defined
-    end
-
-    # Note: this does **not** need to be called when using Haml helpers
-    # normally in Rails.
-    #
-    # Initializes the current object as though it were in the same context
-    # as a normal ActionView instance using Haml.
-    # This is useful if you want to use the helpers in a context
-    # other than the normal setup with ActionView.
-    # For example:
-    #
-    #     context = Object.new
-    #     class << context
-    #       include Haml::Helpers
-    #     end
-    #     context.init_haml_helpers
-    #     context.haml_tag :p, "Stuff"
-    #
-    def init_haml_helpers
-      @haml_buffer = Haml::Buffer.new(haml_buffer, Options.new.for_buffer)
-      nil
-    end
-
-    # Runs a block of code in a non-Haml context
-    # (i.e. \{#is\_haml?} will return false).
-    #
-    # This is mainly useful for rendering sub-templates such as partials in a non-Haml language,
-    # particularly where helpers may behave differently when run from Haml.
-    #
-    # Note that this is automatically applied to Rails partials.
-    #
-    # @yield A block which won't register as Haml
-    def non_haml
-      was_active = @haml_buffer.active?
-      @haml_buffer.active = false
-      yield
-    ensure
-      @haml_buffer.active = was_active
-    end
-
-    # Uses \{#preserve} to convert any newlines inside whitespace-sensitive tags
-    # into the HTML entities for endlines.
-    #
-    # @param tags [Array<String>] Tags that should have newlines escaped
-    #
-    # @overload find_and_preserve(input, tags = haml_buffer.options[:preserve])
-    #   Escapes newlines within a string.
-    #
-    #   @param input [String] The string within which to escape newlines
-    # @overload find_and_preserve(tags = haml_buffer.options[:preserve])
-    #   Escapes newlines within a block of Haml code.
-    #
-    #   @yield The block within which to escape newlines
-    def find_and_preserve(input = nil, tags = haml_buffer.options[:preserve], &block)
-      return find_and_preserve(capture_haml(&block), input || tags) if block
-      re = /<(#{tags.map(&Regexp.method(:escape)).join('|')})([^>]*)>(.*?)(<\/\1>)/im
-      input.to_s.gsub(re) do |s|
-        s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
-        "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
-      end
-    end
-
-    # Takes any string, finds all the newlines, and converts them to
-    # HTML entities so they'll render correctly in
-    # whitespace-sensitive tags without screwing up the indentation.
-    #
-    # @overload perserve(input)
-    #   Escapes newlines within a string.
-    #
-    #   @param input [String] The string within which to escape all newlines
-    # @overload perserve
-    #   Escapes newlines within a block of Haml code.
-    #
-    #   @yield The block within which to escape newlines
-    def preserve(input = nil, &block)
-      return preserve(capture_haml(&block)) if block
-      input.to_s.chomp("\n").gsub(/\n/, '&#x000A;').gsub(/\r/, '')
-    end
-    alias_method :flatten, :preserve
-
-    # Takes an `Enumerable` object and a block
-    # and iterates over the enum,
-    # yielding each element to a Haml block
-    # and putting the result into `<li>` elements.
-    # This creates a list of the results of the block.
-    # For example:
-    #
-    #     = list_of([['hello'], ['yall']]) do |i|
-    #       = i[0]
-    #
-    # Produces:
-    #
-    #     <li>hello</li>
-    #     <li>yall</li>
-    #
-    # And:
-    #
-    #     = list_of({:title => 'All the stuff', :description => 'A book about all the stuff.'}) do |key, val|
-    #       %h3= key.humanize
-    #       %p= val
-    #
-    # Produces:
-    #
-    #     <li>
-    #       <h3>Title</h3>
-    #       <p>All the stuff</p>
-    #     </li>
-    #     <li>
-    #       <h3>Description</h3>
-    #       <p>A book about all the stuff.</p>
-    #     </li>
-    #
-    # While:
-    #
-    #     = list_of(["Home", "About", "Contact", "FAQ"], {class: "nav", role: "nav"}) do |item|
-    #       %a{ href="#" }= item
-    #
-    # Produces:
-    #
-    #     <li class='nav' role='nav'>
-    #       <a href='#'>Home</a>
-    #     </li>
-    #     <li class='nav' role='nav'>
-    #       <a href='#'>About</a>
-    #     </li>
-    #     <li class='nav' role='nav'>
-    #       <a href='#'>Contact</a>
-    #     </li>
-    #     <li class='nav' role='nav'>
-    #       <a href='#'>FAQ</a>
-    #     </li>
-    #
-    #  `[[class", "nav"], [role", "nav"]]` could have been used instead of `{class: "nav", role: "nav"}` (or any enumerable collection where each pair of items responds to #to_s)
-    #
-    # @param enum [Enumerable] The list of objects to iterate over
-    # @param [Enumerable<#to_s,#to_s>] opts Each key/value pair will become an attribute pair for each list item element.
-    # @yield [item] A block which contains Haml code that goes within list items
-    # @yieldparam item An element of `enum`
-    def list_of(enum, opts={}, &block)
-      opts_attributes = opts.empty? ? "" : " ".<<(opts.map{|k,v| "#{k}='#{v}'" }.join(" "))
-      to_return = enum.collect do |i|
-        result = capture_haml(i, &block)
-
-        if result.count("\n") > 1
-          result = result.gsub("\n", "\n  ")
-          result = "\n  #{result.strip}\n"
-        else
-          result = result.strip
-        end
-
-        %Q!<li#{opts_attributes}>#{result}</li>!
-      end
-      to_return.join("\n")
-    end
-
-    # Returns a hash containing default assignments for the `xmlns`, `lang`, and `xml:lang`
-    # attributes of the `html` HTML element.
-    # For example,
-    #
-    #     %html{html_attrs}
-    #
-    # becomes
-    #
-    #     <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
-    #
-    # @param lang [String] The value of `xml:lang` and `lang`
-    # @return [{#to_s => String}] The attribute hash
-    def html_attrs(lang = 'en-US')
-      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
-    end
-
-    # Increments the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    # For example:
-    #
-    #     %h1 foo
-    #     - tab_up
-    #     %p bar
-    #     - tab_down
-    #     %strong baz
-    #
-    # Produces:
-    #
-    #     <h1>foo</h1>
-    #       <p>bar</p>
-    #     <strong>baz</strong>
-    #
-    # @param i [Fixnum] The number of tabs by which to increase the indentation
-    # @see #tab_down
-    def tab_up(i = 1)
-      haml_buffer.tabulation += i
-    end
-
-    # Decrements the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    #
-    # @param i [Fixnum] The number of tabs by which to decrease the indentation
-    # @see #tab_up
-    def tab_down(i = 1)
-      haml_buffer.tabulation -= i
-    end
-
-    # Sets the number of tabs the buffer automatically adds
-    # to the lines of the template,
-    # but only for the duration of the block.
-    # For example:
-    #
-    #     %h1 foo
-    #     - with_tabs(2) do
-    #       %p bar
-    #     %strong baz
-    #
-    # Produces:
-    #
-    #     <h1>foo</h1>
-    #         <p>bar</p>
-    #     <strong>baz</strong>
-    #
-    #
-    # @param i [Fixnum] The number of tabs to use
-    # @yield A block in which the indentation will be `i` spaces
-    def with_tabs(i)
-      old_tabs = haml_buffer.tabulation
-      haml_buffer.tabulation = i
-      yield
-    ensure
-      haml_buffer.tabulation = old_tabs
-    end
-
-    # Surrounds a block of Haml code with strings,
-    # with no whitespace in between.
-    # For example:
-    #
-    #     = surround '(', ')' do
-    #       %a{:href => "food"} chicken
-    #
-    # Produces:
-    #
-    #     (<a href='food'>chicken</a>)
-    #
-    # and
-    #
-    #     = surround '*' do
-    #       %strong angry
-    #
-    # Produces:
-    #
-    #     *<strong>angry</strong>*
-    #
-    # @param front [String] The string to add before the Haml
-    # @param back [String] The string to add after the Haml
-    # @yield A block of Haml to surround
-    def surround(front, back = front, &block)
-      output = capture_haml(&block)
-
-      "#{front}#{output.chomp}#{back}\n"
-    end
-
-    # Prepends a string to the beginning of a Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #     = precede '*' do
-    #       %span.small Not really
-    #
-    # Produces:
-    #
-    #     *<span class='small'>Not really</span>
-    #
-    # @param str [String] The string to add before the Haml
-    # @yield A block of Haml to prepend to
-    def precede(str, &block)
-      "#{str}#{capture_haml(&block).chomp}\n"
-    end
-
-    # Appends a string to the end of a Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #     click
-    #     = succeed '.' do
-    #       %a{:href=>"thing"} here
-    #
-    # Produces:
-    #
-    #     click
-    #     <a href='thing'>here</a>.
-    #
-    # @param str [String] The string to add after the Haml
-    # @yield A block of Haml to append to
-    def succeed(str, &block)
-      "#{capture_haml(&block).chomp}#{str}\n"
-    end
-
-    # Captures the result of a block of Haml code,
-    # gets rid of the excess indentation,
-    # and returns it as a string.
-    # For example, after the following,
-    #
-    #     .foo
-    #       - foo = capture_haml(13) do |a|
-    #         %p= a
-    #
-    # the local variable `foo` would be assigned to `"<p>13</p>\n"`.
-    #
-    # @param args [Array] Arguments to pass into the block
-    # @yield [args] A block of Haml code that will be converted to a string
-    # @yieldparam args [Array] `args`
-    def capture_haml(*args, &block)
-      buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer
-      with_haml_buffer(buffer) do
-        position = haml_buffer.buffer.length
-
-        haml_buffer.capture_position = position
-        value = block.call(*args)
-
-        captured = haml_buffer.buffer.slice!(position..-1)
-
-        if captured == '' and value != haml_buffer.buffer
-             captured = (value.is_a?(String) ? value : nil)
-        end
-
-        return nil if captured.nil?
-        return (haml_buffer.options[:ugly] ? captured : prettify(captured))
-
-      end
-    ensure
-      haml_buffer.capture_position = nil
-    end
-
-    # Outputs text directly to the Haml buffer, with the proper indentation.
-    #
-    # @param text [#to_s] The text to output
-    def haml_concat(text = "")
-      unless haml_buffer.options[:ugly] || haml_indent == 0
-        haml_buffer.buffer << haml_indent <<
-          text.to_s.gsub("\n", "\n" + haml_indent) << "\n"
-      else
-        haml_buffer.buffer << text.to_s << "\n"
-      end
-      ErrorReturn.new("haml_concat")
-    end
-
-    # @return [String] The indentation string for the current line
-    def haml_indent
-      '  ' * haml_buffer.tabulation
-    end
-
-    # Creates an HTML tag with the given name and optionally text and attributes.
-    # Can take a block that will run between the opening and closing tags.
-    # If the block is a Haml block or outputs text using \{#haml\_concat},
-    # the text will be properly indented.
-    #
-    # `name` can be a string using the standard Haml class/id shorthand
-    # (e.g. "span#foo.bar", "#foo").
-    # Just like standard Haml tags, these class and id values
-    # will be merged with manually-specified attributes.
-    #
-    # `flags` is a list of symbol flags
-    # like those that can be put at the end of a Haml tag
-    # (`:/`, `:<`, and `:>`).
-    # Currently, only `:/` and `:<` are supported.
-    #
-    # `haml_tag` outputs directly to the buffer;
-    # its return value should not be used.
-    # If you need to get the results as a string,
-    # use \{#capture\_haml\}.
-    #
-    # For example,
-    #
-    #     haml_tag :table do
-    #       haml_tag :tr do
-    #         haml_tag 'td.cell' do
-    #           haml_tag :strong, "strong!"
-    #           haml_concat "data"
-    #         end
-    #         haml_tag :td do
-    #           haml_concat "more_data"
-    #         end
-    #       end
-    #     end
-    #
-    # outputs
-    #
-    #     <table>
-    #       <tr>
-    #         <td class='cell'>
-    #           <strong>
-    #             strong!
-    #           </strong>
-    #           data
-    #         </td>
-    #         <td>
-    #           more_data
-    #         </td>
-    #       </tr>
-    #     </table>
-    #
-    # @param name [#to_s] The name of the tag
-    #
-    # @overload haml_tag(name, *rest, attributes = {})
-    #   @yield The block of Haml code within the tag
-    # @overload haml_tag(name, text, *flags, attributes = {})
-    #   @param text [#to_s] The text within the tag
-    #   @param flags [Array<Symbol>] Haml end-of-tag flags
-    def haml_tag(name, *rest, &block)
-      ret = ErrorReturn.new("haml_tag")
-
-      text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
-      flags = []
-      flags << rest.shift while rest.first.is_a? Symbol
-      attrs = (rest.shift || {})
-      attrs.keys.each {|key| attrs[key.to_s] = attrs.delete(key)} unless attrs.empty?
-      name, attrs = merge_name_and_attributes(name.to_s, attrs)
-
-      attributes = Haml::Compiler.build_attributes(haml_buffer.html?,
-        haml_buffer.options[:attr_wrapper],
-        haml_buffer.options[:escape_attrs],
-        haml_buffer.options[:hyphenate_data_attrs],
-        attrs)
-
-      if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
-        haml_concat "<#{name}#{attributes} />"
-        return ret
-      end
-
-      if flags.include?(:/)
-        raise Error.new(Error.message(:self_closing_content)) if text
-        raise Error.new(Error.message(:illegal_nesting_self_closing)) if block
-      end
-
-      tag = "<#{name}#{attributes}>"
-      if block.nil?
-        text = text.to_s
-        if text.include?("\n")
-          haml_concat tag
-          tab_up
-          haml_concat text
-          tab_down
-          haml_concat "</#{name}>"
-        else
-          tag << text << "</#{name}>"
-          haml_concat tag
-        end
-        return ret
-      end
-
-      if text
-        raise Error.new(Error.message(:illegal_nesting_line, name))
-      end
-
-      if flags.include?(:<)
-        tag << capture_haml(&block).strip << "</#{name}>"
-        haml_concat tag
-        return ret
-      end
-
-      haml_concat tag
-      tab_up
-      block.call
-      tab_down
-      haml_concat "</#{name}>"
-
-      ret
-    end
-
-    # Characters that need to be escaped to HTML entities from user input
-    HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
-
-    HTML_ESCAPE_REGEX = /[\"><&]/
-
-    if RUBY_VERSION >= '1.9'
-      # Include docs here so they are picked up by Yard
-
-      # Returns a copy of `text` with ampersands, angle brackets and quotes
-      # escaped into HTML entities.
-      #
-      # Note that if ActionView is loaded and XSS protection is enabled
-      # (as is the default for Rails 3.0+, and optional for version 2.3.5+),
-      # this won't escape text declared as "safe".
-      #
-      # @param text [String] The string to sanitize
-      # @return [String] The sanitized string
-      def html_escape(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE)
-      end
-    else
-      def html_escape(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_REGEX) {|s| HTML_ESCAPE[s]}
-      end
-    end
-
-    HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|(#\d+));)/
-
-    if RUBY_VERSION >= '1.9'
-      # Include docs here so they are picked up by Yard
-
-      # Escapes HTML entities in `text`, but without escaping an ampersand
-      # that is already part of an escaped entity.
-      #
-      # @param text [String] The string to sanitize
-      # @return [String] The sanitized string
-      def escape_once(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
-      end
-    else
-      def escape_once(text)
-        text = text.to_s
-        text.gsub(HTML_ESCAPE_ONCE_REGEX){|s| HTML_ESCAPE[s]}
-      end
-    end
-
-    # Returns whether or not the current template is a Haml template.
-    #
-    # This function, unlike other {Haml::Helpers} functions,
-    # also works in other `ActionView` templates,
-    # where it will always return false.
-    #
-    # @return [Boolean] Whether or not the current template is a Haml template
-    def is_haml?
-      !@haml_buffer.nil? && @haml_buffer.active?
-    end
-
-    # Returns whether or not `block` is defined directly in a Haml template.
-    #
-    # @param block [Proc] A Ruby block
-    # @return [Boolean] Whether or not `block` is defined directly in a Haml template
-    def block_is_haml?(block)
-      eval('!!defined?(_hamlout)', block.binding)
-    end
-
-    private
-
-    # Parses the tag name used for \{#haml\_tag}
-    # and merges it with the Ruby attributes hash.
-    def merge_name_and_attributes(name, attributes_hash = {})
-      # skip merging if no ids or classes found in name
-      return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
-
-      return $1 || "div", Buffer.merge_attrs(
-        Haml::Parser.parse_class_and_id($2), attributes_hash)
-    end
-
-    # Runs a block of code with the given buffer as the currently active buffer.
-    #
-    # @param buffer [Haml::Buffer] The Haml buffer to use temporarily
-    # @yield A block in which the given buffer should be used
-    def with_haml_buffer(buffer)
-      @haml_buffer, old_buffer = buffer, @haml_buffer
-      old_buffer.active, old_was_active = false, old_buffer.active? if old_buffer
-      @haml_buffer.active, was_active = true, @haml_buffer.active?
-      yield
-    ensure
-      @haml_buffer.active = was_active
-      old_buffer.active = old_was_active if old_buffer
-      @haml_buffer = old_buffer
-    end
-
-    # The current {Haml::Buffer} object.
-    #
-    # @return [Haml::Buffer]
-    def haml_buffer
-      @haml_buffer if defined? @haml_buffer
-    end
-
-    # Gives a proc the same local `_hamlout` and `_erbout` variables
-    # that the current template has.
-    #
-    # @param proc [#call] The proc to bind
-    # @return [Proc] A new proc with the new variables bound
-    def haml_bind_proc(&proc)
-      _hamlout = haml_buffer
-      #double assignment is to avoid warnings
-      _erbout = _erbout = _hamlout.buffer
-      proc { |*args| proc.call(*args) }
-    end
-
-    def prettify(text)
-      text = text.split(/^/)
-      text.delete('')
-
-      min_tabs = nil
-      text.each do |line|
-        tabs = line.index(/[^ ]/) || line.length
-        min_tabs ||= tabs
-        min_tabs = min_tabs > tabs ? tabs : min_tabs
-      end
-
-      text.map do |line|
-        line.slice(min_tabs, line.length)
-      end.join
-    end
-  end
-end
-
-# @private
-class Object
-  # Haml overrides various `ActionView` helpers,
-  # which call an \{#is\_haml?} method
-  # to determine whether or not the current context object
-  # is a proper Haml context.
-  # Because `ActionView` helpers may be included in non-`ActionView::Base` classes,
-  # it's a good idea to define \{#is\_haml?} for all objects.
-  def is_haml?
-    false
-  end
-end
-