brakeman 4.3.1 → 5.0.0

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

@@ -1,58 +0,0 @@
-module Haml
-  module Helpers
-    @@action_view_defined = true
-
-    # This module contains various useful helper methods
-    # that either tie into ActionView or the rest of the ActionPack stack,
-    # or are only useful in that context.
-    # Thus, the methods defined here are only available
-    # if ActionView is installed.
-    module ActionViewExtensions
-      # Returns a value for the "class" attribute
-      # unique to this controller/action pair.
-      # This can be used to target styles specifically at this action or controller.
-      # For example, if the current action were `EntryController#show`,
-      #
-      #     %div{:class => page_class} My Div
-      #
-      # would become
-      #
-      #     <div class="entry show">My Div</div>
-      #
-      # Then, in a stylesheet (shown here as [Sass](http://sass-lang.com)),
-      # you could refer to this specific action:
-      #
-      #     .entry.show
-      #       font-weight: bold
-      #
-      # or to all actions in the entry controller:
-      #
-      #     .entry
-      #       color: #00f
-      #
-      # @return [String] The class name for the current page
-      def page_class
-        controller.controller_name + " " + controller.action_name
-      end
-      alias_method :generate_content_class_names, :page_class
-
-      # Treats all input to \{Haml::Helpers#haml\_concat} within the block
-      # as being HTML safe for Rails' XSS protection.
-      # This is useful for wrapping blocks of code that concatenate HTML en masse.
-      #
-      # This has no effect if Rails' XSS protection isn't enabled.
-      #
-      # @yield A block in which all input to `#haml_concat` is treated as raw.
-      # @see Haml::Util#rails_xss_safe?
-      def with_raw_haml_concat
-        old = instance_variable_defined?('@_haml_concat_raw') ? @_haml_concat_raw : false
-        @_haml_concat_raw = true
-        yield
-      ensure
-        @_haml_concat_raw = old
-      end
-    end
-
-    include ActionViewExtensions
-  end
-end

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

@@ -1,147 +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
-
-    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_buffer)
-      if is_haml?
-        if Haml::Util.rails_xss_safe? && new_buffer.is_a?(ActiveSupport::SafeBuffer)
-          new_buffer = String.new(new_buffer)
-        end
-        haml_buffer.buffer = new_buffer
-      else
-        set_output_buffer_without_haml new_buffer
-      end
-    end
-    alias_method :set_output_buffer_without_haml, :output_buffer=
-    alias_method :output_buffer=, :set_output_buffer_with_haml
-  end
-
-  module Helpers
-    module CaptureHelper
-      def capture_with_haml(*args, &block)
-        if Haml::Helpers.block_is_haml?(block)
-          #double assignment is to avoid warnings
-          _hamlout = _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
-
-          str = capture_haml(*args, &block)
-
-          # NonCattingString is present in Rails less than 3.1.0. When support
-          # for 3.0 is dropped, this can be removed.
-          return ActionView::NonConcattingString.new(str) if str && defined?(ActionView::NonConcattingString)
-          return str
-        else
-          capture_without_haml(*args, &block)
-        end
-      end
-      alias_method :capture_without_haml, :capture
-      alias_method :capture, :capture_with_haml
-    end
-
-    module TagHelper
-      def content_tag_with_haml(name, *args, &block)
-        return content_tag_without_haml(name, *args, &block) unless is_haml?
-
-        preserve = haml_buffer.options[:preserve].include?(name.to_s)
-
-        if block_given? && block_is_haml?(block) && preserve
-          return content_tag_without_haml(name, *args) {preserve(&block)}
-        end
-
-        content = content_tag_without_haml(name, *args, &block)
-        content = Haml::Helpers.preserve(content) if preserve && content
-        content
-      end
-
-      alias_method :content_tag_without_haml, :content_tag
-      alias_method :content_tag, :content_tag_with_haml
-    end
-
-    module HamlSupport
-      include Haml::Helpers
-
-      def haml_buffer
-        @template_object.send :haml_buffer
-      end
-
-      def is_haml?
-        @template_object.send :is_haml?
-      end
-    end
-
-    if ActionPack::VERSION::MAJOR == 4
-      module Tags
-        class TextArea
-          include HamlSupport
-        end
-      end
-    end
-
-    class InstanceTag
-      include HamlSupport
-
-      def content_tag(*args, &block)
-        html_tag = content_tag_with_haml(*args, &block)
-        return html_tag unless respond_to?(:error_wrapping)
-        return error_wrapping(html_tag) if method(:error_wrapping).arity == 1
-        return html_tag unless object.respond_to?(:errors) && object.errors.respond_to?(:on)
-        return error_wrapping(html_tag, object.errors.on(@method_name))
-      end
-    end
-
-    module FormTagHelper
-      def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-        if is_haml?
-          wrap_block = block_given? && block_is_haml?(proc)
-          if wrap_block
-            oldproc = proc
-            proc = haml_bind_proc do |*args|
-              concat "\n"
-              with_tabs(1) {oldproc.call(*args)}
-            end
-          end
-          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-          res << "\n" if wrap_block
-          res
-        else
-          form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-        end
-      end
-      alias_method :form_tag_without_haml, :form_tag
-      alias_method :form_tag, :form_tag_with_haml
-    end
-
-    module FormHelper
-      def form_for_with_haml(object_name, *args, &proc)
-        wrap_block = block_given? && is_haml? && block_is_haml?(proc)
-        if wrap_block
-          oldproc = proc
-          proc = proc {|*subargs| with_tabs(1) {oldproc.call(*subargs)}}
-        end
-        res = form_for_without_haml(object_name, *args, &proc)
-        res << "\n" if wrap_block
-        res
-      end
-      alias_method :form_for_without_haml, :form_for
-      alias_method :form_for, :form_for_with_haml
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-module ActionView
-  module Helpers
-    module CaptureHelper
-      def with_output_buffer_with_haml_xss(*args, &block)
-        res = with_output_buffer_without_haml_xss(*args, &block)
-        case res
-        when Array; res.map {|s| Haml::Util.html_safe(s)}
-        when String; Haml::Util.html_safe(res)
-        else; res
-        end
-      end
-      alias_method :with_output_buffer_without_haml_xss, :with_output_buffer
-      alias_method :with_output_buffer, :with_output_buffer_with_haml_xss
-    end
-
-    module FormTagHelper
-      def form_tag_with_haml_xss(*args, &block)
-        res = form_tag_without_haml_xss(*args, &block)
-        res = Haml::Util.html_safe(res) unless block_given?
-        res
-      end
-      alias_method :form_tag_without_haml_xss, :form_tag
-      alias_method :form_tag, :form_tag_with_haml_xss
-    end
-
-    module FormHelper
-      def form_for_with_haml_xss(*args, &block)
-        res = form_for_without_haml_xss(*args, &block)
-        return Haml::Util.html_safe(res) if res.is_a?(String)
-        return res
-      end
-      alias_method :form_for_without_haml_xss, :form_for
-      alias_method :form_for, :form_for_with_haml_xss
-    end
-
-    module TextHelper
-      def concat_with_haml_xss(string)
-        if is_haml?
-          haml_buffer.buffer.concat(haml_xss_html_escape(string))
-        else
-          concat_without_haml_xss(string)
-        end
-      end
-      alias_method :concat_without_haml_xss, :concat
-      alias_method :concat, :concat_with_haml_xss
-
-      def safe_concat_with_haml_xss(string)
-        if is_haml?
-          haml_buffer.buffer.concat(string)
-        else
-          safe_concat_without_haml_xss(string)
-        end
-      end
-      alias_method :safe_concat_without_haml_xss, :safe_concat
-      alias_method :safe_concat, :safe_concat_with_haml_xss
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Haml
-
-  class ErubisTemplateHandler < ActionView::Template::Handlers::Erubis
-
-    def initialize(*args, &blk)
-      @newline_pending = 0
-      super
-    end
-  end
-
-  class SafeErubisTemplate < Tilt::ErubisTemplate
-
-    def initialize_engine
-    end
-
-    def prepare
-      @options.merge! :engine_class => Haml::ErubisTemplateHandler
-      super
-    end
-
-    def precompiled_preamble(locals)
-      [super, "@output_buffer = ActionView::OutputBuffer.new;"].join("\n")
-    end
-
-    def precompiled_postamble(locals)
-      [super, '@output_buffer.to_s'].join("\n")
-    end
-  end
-end

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

@@ -1,104 +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?
-        Haml::Util.html_safe(html_escape_without_haml_xss(str))
-      end
-
-      # Output is always HTML safe
-      def find_and_preserve_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(find_and_preserve_without_haml_xss(*args, &block))
-      end
-
-      # Output is always HTML safe
-      def preserve_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(preserve_without_haml_xss(*args, &block))
-      end
-
-      # Output is always HTML safe
-      def list_of_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(list_of_without_haml_xss(*args, &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def surround_with_haml_xss(front, back = front, &block)
-        Haml::Util.html_safe(
-          surround_without_haml_xss(
-            haml_xss_html_escape(front),
-            haml_xss_html_escape(back),
-            &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def precede_with_haml_xss(str, &block)
-        Haml::Util.html_safe(precede_without_haml_xss(haml_xss_html_escape(str), &block))
-      end
-
-      # Input is escaped, output is always HTML safe
-      def succeed_with_haml_xss(str, &block)
-        Haml::Util.html_safe(succeed_without_haml_xss(haml_xss_html_escape(str), &block))
-      end
-
-      # Output is always HTML safe
-      def capture_haml_with_haml_xss(*args, &block)
-        Haml::Util.html_safe(capture_haml_without_haml_xss(*args, &block))
-      end
-
-      # Input is escaped
-      def haml_concat_with_haml_xss(text = "")
-        raw = instance_variable_defined?('@_haml_concat_raw') ? @_haml_concat_raw : false
-        haml_concat_without_haml_xss(raw ? text : haml_xss_html_escape(text))
-      end
-
-      # Output is always HTML safe
-      def haml_indent_with_haml_xss
-        Haml::Util.html_safe(haml_indent_without_haml_xss)
-      end
-
-      # Input is escaped, haml_concat'ed output is always HTML safe
-      def haml_tag_with_haml_xss(name, *rest, &block)
-        name = haml_xss_html_escape(name.to_s)
-        rest.unshift(haml_xss_html_escape(rest.shift.to_s)) unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
-        with_raw_haml_concat {haml_tag_without_haml_xss(name, *rest, &block)}
-      end
-
-      # Output is always HTML safe
-      def escape_once_with_haml_xss(*args)
-        Haml::Util.html_safe(escape_once_without_haml_xss(*args))
-      end
-
-      private
-
-      # Escapes the HTML in the text if and only if
-      # Rails XSS protection is enabled *and* the `:escape_html` option is set.
-      def haml_xss_html_escape(text)
-        return text unless Haml::Util.rails_xss_safe? && haml_buffer.options[:escape_html]
-        html_escape(text)
-      end
-    end
-
-    class ErrorReturn
-      # Any attempt to treat ErrorReturn as a string should cause it to blow up.
-      alias_method :html_safe, :to_s
-      alias_method :html_safe?, :to_s
-      alias_method :html_safe!, :to_s
-    end
-  end
-end

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

@@ -1,279 +0,0 @@
-module Haml
-  # This class encapsulates all of the configuration options that Haml
-  # understands. Please see the {file:REFERENCE.md#options Haml Reference} to
-  # learn how to set the options.
-  class Options
-
-    @defaults = {
-      :attr_wrapper         => "'",
-      :autoclose            => %w(area base basefont br col command embed frame
-                                  hr img input isindex keygen link menuitem meta
-                                  param source track wbr),
-      :encoding             => "UTF-8",
-      :escape_attrs         => true,
-      :escape_html          => false,
-      :filename             => '(haml)',
-      :format               => :html5,
-      :hyphenate_data_attrs => true,
-      :line                 => 1,
-      :mime_type            => 'text/html',
-      :preserve             => %w(textarea pre code),
-      :remove_whitespace    => false,
-      :suppress_eval        => false,
-      :ugly                 => false,
-      :cdata                => false,
-      :parser_class         => ::Haml::Parser,
-      :compiler_class       => ::Haml::Compiler
-    }
-
-    @valid_formats = [:html4, :html5, :xhtml]
-
-    @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :ugly, :format,
-      :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs, :cdata]
-
-    # The default option values.
-    # @return Hash
-    def self.defaults
-      @defaults
-    end
-
-    # An array of valid values for the `:format` option.
-    # @return Array
-    def self.valid_formats
-      @valid_formats
-    end
-
-    # An array of keys that will be used to provide a hash of options to
-    # {Haml::Buffer}.
-    # @return Hash
-    def self.buffer_option_keys
-      @buffer_option_keys
-    end
-
-    # The character that should wrap element attributes. This defaults to `'`
-    # (an apostrophe). Characters of this type within the attributes will be
-    # escaped (e.g. by replacing them with `'`) if the character is an
-    # apostrophe or a quotation mark.
-    attr_reader :attr_wrapper
-
-    # A list of tag names that should be automatically self-closed if they have
-    # no content. This can also contain regular expressions that match tag names
-    # (or any object which responds to `#===`). Defaults to `['meta', 'img',
-    # 'link', 'br', 'hr', 'input', 'area', 'param', 'col', 'base']`.
-    attr_accessor :autoclose
-
-    # The encoding to use for the HTML output.
-    # Only available on Ruby 1.9 or higher.
-    # This can be a string or an `Encoding` Object. Note that Haml **does not**
-    # automatically re-encode Ruby values; any strings coming from outside the
-    # application should be converted before being passed into the Haml
-    # template. Defaults to `Encoding.default_internal`; if that's not set,
-    # defaults to the encoding of the Haml template; if that's `US-ASCII`,
-    # defaults to `"UTF-8"`.
-    attr_reader :encoding
-
-    # Sets whether or not to escape HTML-sensitive characters in attributes. If
-    # this is true, all HTML-sensitive characters in attributes are escaped. If
-    # it's set to false, no HTML-sensitive characters in attributes are escaped.
-    # If it's set to `:once`, existing HTML escape sequences are preserved, but
-    # other HTML-sensitive characters are escaped.
-    #
-    # Defaults to `true`.
-    attr_accessor :escape_attrs
-
-    # Sets whether or not to escape HTML-sensitive characters in script. If this
-    # is true, `=` behaves like {file:REFERENCE.md#escaping_html `&=`};
-    # otherwise, it behaves like {file:REFERENCE.md#unescaping_html `!=`}. Note
-    # that if this is set, `!=` should be used for yielding to subtemplates and
-    # rendering partials. See also {file:REFERENCE.md#escaping_html Escaping HTML} and
-    # {file:REFERENCE.md#unescaping_html Unescaping HTML}.
-    #
-    # Defaults to false.
-    attr_accessor :escape_html
-
-    # The name of the Haml file being parsed.
-    # This is only used as information when exceptions are raised. This is
-    # automatically assigned when working through ActionView, so it's really
-    # only useful for the user to assign when dealing with Haml programatically.
-    attr_accessor :filename
-
-    # If set to `true`, Haml will convert underscores to hyphens in all
-    # {file:REFERENCE.md#html5_custom_data_attributes Custom Data Attributes} As
-    # of Haml 4.0, this defaults to `true`.
-    attr_accessor :hyphenate_data_attrs
-
-    # The line offset of the Haml template being parsed. This is useful for
-    # inline templates, similar to the last argument to `Kernel#eval`.
-    attr_accessor :line
-
-    # Determines the output format. The default is `:html5`. The other options
-    # are `:html4` and `:xhtml`. If the output is set to XHTML, then Haml
-    # automatically generates self-closing tags and wraps the output of the
-    # Javascript and CSS-like filters inside CDATA. When the output is set to
-    # `:html5` or `:html4`, XML prologs are ignored. In all cases, an appropriate
-    # doctype is generated from `!!!`.
-    #
-    # If the mime_type of the template being rendered is `text/xml` then a
-    # format of `:xhtml` will be used even if the global output format is set to
-    # `:html4` or `:html5`.
-    attr :format
-
-    # The mime type that the rendered document will be served with. If this is
-    # set to `text/xml` then the format will be overridden to `:xhtml` even if
-    # it has set to `:html4` or `:html5`.
-    attr_accessor :mime_type
-
-    # A list of tag names that should automatically have their newlines
-    # preserved using the {Haml::Helpers#preserve} helper. This means that any
-    # content given on the same line as the tag will be preserved. For example,
-    # `%textarea= "Foo\nBar"` compiles to `<textarea>Foo&#x000A;Bar</textarea>`.
-    # Defaults to `['textarea', 'pre']`. See also
-    # {file:REFERENCE.md#whitespace_preservation Whitespace Preservation}.
-    attr_accessor :preserve
-
-    # If set to `true`, all tags are treated as if both
-    # {file:REFERENCE.md#whitespace_removal__and_ whitespace removal} options
-    # were present. Use with caution as this may cause whitespace-related
-    # formatting errors.
-    #
-    # Defaults to `false`.
-    attr_reader :remove_whitespace
-
-    # Whether or not attribute hashes and Ruby scripts designated by `=` or `~`
-    # should be evaluated. If this is `true`, said scripts are rendered as empty
-    # strings.
-    #
-    # Defaults to `false`.
-    attr_accessor :suppress_eval
-
-    # If set to `true`, Haml makes no attempt to properly indent or format the
-    # HTML output. This significantly improves rendering performance but makes
-    # viewing the source unpleasant.
-    #
-    # Defaults to `true` in Rails production  mode, and `false` everywhere else.
-    attr_accessor :ugly
-
-    # Whether to include CDATA sections around javascript and css blocks when
-    # using the `:javascript` or `:css` filters.
-    #
-    # This option also affects the `:sass`, `:scss`, `:less` and `:coffeescript`
-    # filters.
-    #
-    # Defaults to `false` for html, `true` for xhtml. Cannot be changed when using
-    # xhtml.
-    attr_accessor :cdata
-
-    # The parser class to use. Defaults to Haml::Parser.
-    attr_accessor :parser_class
-
-    # The compiler class to use. Defaults to Haml::Compiler.
-    attr_accessor :compiler_class
-
-    def initialize(values = {}, &block)
-      defaults.each {|k, v| instance_variable_set :"@#{k}", v}
-      values.reject {|k, v| !defaults.has_key?(k) || v.nil?}.each {|k, v| send("#{k}=", v)}
-      yield if block_given?
-    end
-
-    # Retrieve an option value.
-    # @param key The value to retrieve.
-    def [](key)
-      send key
-    end
-
-    # Set an option value.
-    # @param key The key to set.
-    # @param value The value to set for the key.
-    def []=(key, value)
-      send "#{key}=", value
-    end
-
-    [:escape_attrs, :hyphenate_data_attrs, :remove_whitespace, :suppress_eval,
-      :ugly].each do |method|
-      class_eval(<<-END)
-        def #{method}?
-          !! @#{method}
-        end
-      END
-    end
-
-    # @return [Boolean] Whether or not the format is XHTML.
-    def xhtml?
-      not html?
-    end
-
-    # @return [Boolean] Whether or not the format is any flavor of HTML.
-    def html?
-      html4? or html5?
-    end
-
-    # @return [Boolean] Whether or not the format is HTML4.
-    def html4?
-      format == :html4
-    end
-
-    # @return [Boolean] Whether or not the format is HTML5.
-    def html5?
-      format == :html5
-    end
-
-    def attr_wrapper=(value)
-      @attr_wrapper = value || self.class.defaults[:attr_wrapper]
-    end
-
-    # Undef :format to suppress warning. It's defined above with the `:attr`
-    # macro in order to make it appear in Yard's list of instance attributes.
-    undef :format
-    def format
-      mime_type == "text/xml" ? :xhtml : @format
-    end
-
-    def format=(value)
-      unless self.class.valid_formats.include?(value)
-        raise Haml::Error, "Invalid output format #{value.inspect}"
-      end
-      @format = value
-    end
-
-    undef :cdata
-    def cdata
-      xhtml? || @cdata
-    end
-
-    def remove_whitespace=(value)
-      @ugly = true if value
-      @remove_whitespace = value
-    end
-
-    if RUBY_VERSION < "1.9"
-      attr_writer :encoding
-    else
-      def encoding=(value)
-        return unless value
-        @encoding = value.is_a?(Encoding) ? value.name : value.to_s
-        @encoding = "UTF-8" if @encoding.upcase == "US-ASCII"
-      end
-    end
-
-    # Returns a subset of options: those that {Haml::Buffer} cares about.
-    # All of the values here are such that when `#inspect` is called on the hash,
-    # it can be `Kernel#eval`ed to get the same result back.
-    #
-    # See {file:REFERENCE.md#options the Haml options documentation}.
-    #
-    # @return [{Symbol => Object}] The options hash
-    def for_buffer
-      self.class.buffer_option_keys.inject({}) do |hash, key|
-        hash[key] = send(key)
-        hash
-      end
-    end
-
-    private
-
-    def defaults
-      self.class.defaults
-    end
-
-  end
-end