zuora_connect_ui 0.7.1 → 0.8.0

data/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,58 @@
+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/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/helpers/action_view_mods.rb

@@ -0,0 +1,147 @@
+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/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/helpers/action_view_xss_mods.rb

@@ -0,0 +1,58 @@
+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/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/helpers/safe_erubis_template.rb

@@ -0,0 +1,29 @@
+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/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/helpers/xss_mods.rb

@@ -0,0 +1,104 @@
+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/vendor/ruby/2.6.0/gems/brakeman-4.6.1/bundle/ruby/2.6.0/gems/haml-4.0.7/lib/haml/options.rb

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